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

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

.cvsignore

@@ -0,0 +1,11 @@
+system.list
+bin
+.gdb_history
+Test
+config.cache
+config.status
+system.list
+linux.system.cache
+wx-config
+config.log
+linux-gnu.system.cache

Makefile

@@ -0,0 +1,173 @@
+# Top-level Makefile for wxGTK by Wolfram Gloger
+# based on the version for wx-Xt by Martin Sperl
+
+SHELL=/bin/sh
+
+#if DIRS are defind make only executes in these diretories
+all::
+	@if test "x$(DIRS)" = x; then \
+	  for i in src samples utils user; do \
+	    echo "entering directory $$i building $@"; \
+	    (cd $$i; ${MAKE} -k $@); \
+	  done; \
+	else \
+	  for i in $(DIRS) xxx; do \
+	    if test "$$i" != xxx; then \
+	      echo "entering directory $$i building $@"; \
+	      (cd $$i; ${MAKE} -k $@); \
+	    fi; \
+	  done; \
+	fi	    
+
+# what to do if a target is not understood:
+# pass it on to all the children...
+
+.DEFAULT::
+	@if test "x$(DIRS)" = x; then \
+	  for i in src samples utils user; do \
+	    echo "entering directory $$i building $@"; \
+	    (cd $$i; ${MAKE} -k $@); \
+	  done; \
+	else \
+	  for i in $(DIRS) xxx; do \
+	    if test "$$i" != xxx; then \
+	      echo "entering directory $$i building $@"; \
+	      (cd $$i; ${MAKE} -k $@); \
+	    fi; \
+	  done; \
+	fi
+
+src::
+	@echo "entering directory src building all"
+	@cd src; ${MAKE} all
+
+samples::
+	@echo "entering directory samples building all"
+	@cd samples; ${MAKE} all
+
+utils::
+	@echo "entering directory utils building all"
+	@cd utils; ${MAKE} all
+
+user::
+	@echo "entering directory user building all"
+	@cd user; ${MAKE} all
+
+install::
+	@echo "entering directory src for installing"
+	@cd src; ${MAKE} install
+	@echo "entering directory utils for installing"
+	@cd utils; ${MAKE} install
+	
+# the following ones recreate all Makefiles.
+
+makefiles:: recreate
+Makefiles:: recreate
+recreate::
+	@setup/general/createall
+
+# the following ones define what needs to be done to distribute the 
+# library and its components
+
+distribute:: distrib
+distrib:: distrib_base distrib_user join_utils join_samples
+
+distrib_samples::
+	@echo "entering directory samples creating distribution files"
+	@(cd samples; ${MAKE} -k distrib)
+
+distrib_user::
+	@echo "entering directory user creating distribution files"
+	@(cd user; ${MAKE} -k distrib)
+
+distrib_utils:: 
+	@echo "entering directory utils creating distribution files"
+	@(cd utils; ${MAKE} -k distrib)
+
+join_utils:: distrib_utils
+	@$(MAKE) join \
+	    BASEDIR=utils \
+	    FILES=`echo distrib/utils/*.tgz `
+
+join_samples:: distrib_samples
+	@$(MAKE) join \
+	    BASEDIR=samples \
+	    FILES=`echo distrib/samples/*.tgz `
+
+join_user:: distrib_user
+	@$(MAKE) join \
+	    BASEDIR=user \
+	    FILES=`echo distrib/user/*.tgz `
+
+join::
+	@# needed are BASEDIR and FILES
+	@if test "x$$BASEDIR" = x; then\
+	  echo "BASEDIR not specified.";\
+	  exit -1;\
+	fi
+	@if test "x$$FILES" != x ; then \
+	  echo "putting all seperate distribution files:";\
+	  echo "$$FILES";\
+	  echo "into distrib/$(BASEDIR).tgz";\
+	  src/gtk/setup/general/jointar $(BASEDIR) $$FILES distrib/$(BASEDIR).tgz; \
+	else \
+	  echo "Nothing to join - deleting..."; \
+	  echo "This may be the case, if you have not specified FILES."\
+	  rm -f distrib/$(BASEDIR).tgz; \
+	fi
+
+distrib_base:: 
+	@if test ! -d distrib ; then mkdir distrib; fi;
+	@if test ! -f system.list ; then \
+	  echo "dummy" > system.list;\
+	fi
+	@(curr=`pwd`; direc=`basename $$curr`;\
+	 (cd ..; \
+	  echo creating distrib/$$direc.tar from the current directory;\
+	  tar -cf /tmp/$$direc.tar \
+	    $$direc/COPYING\
+	    $$direc/INSTALL\
+	    $$direc/Makefile\
+	    $$direc/template.mak\
+	    $$direc/configure\
+	    $$direc/configure.in\
+	    $$direc/config.guess\
+	    $$direc/config.sub\
+	    $$direc/install-sh\
+	    $$direc/user/Makefile \
+	    $$direc/utils/Makefile \
+	    $$direc/samples/Makefile \
+	    ;\
+	  sed "s|^\(.*\)$$|/\1/|g" $$direc/system.list \
+	    | uniq > /tmp/$$direc.list; \
+	  echo "/RCS/" >> /tmp/$$direc.list; \
+	  for each in misc docs wx src setup; do \
+	    tar -uf /tmp/$$direc.tar \
+	      `\
+	       find $$direc/$$each \( -type f -o -type l \) -print \
+	       | fgrep -vf /tmp/$$direc.list \
+	       | grep -v "[~#]$$" \
+	      ` ;\
+	  done; \
+	  echo compressing $$direc.tar to $$direc.tgz;\
+	  gzip -9 -c /tmp/$$direc.tar > $$direc/distrib/$$direc.tgz;\
+	  rm /tmp/$$direc.tar /tmp/$$direc.list;\
+	 )\
+	)
+
+# the following ones are only needed if configure.in has changed
+# and needs to be updated...
+
+config:: configure
+
+configure::
+	@autoconf
+	@cat configure \
+	  | sed "s/config.cache/\$$OSTYPE.config.cache/g" \
+	  | sed "s/config.status/\$$OSTYPE.config.status/g" \
+	  | sed "s/\*\*--/  --/g" \
+	  > configure1
+	@chmod a+x configure1
+	@mv configure1 configure
+
+

TODO.txt

@@ -0,0 +1,42 @@
+********************* TODO list for wxWindows 2 ******************************
+
+=============================== common ========================================
+
+wxSocket, wxTCP etc..
+
+wxMultiMedia
+
+=============================== generic  ======================================
+
+wxTreeCtrl keyboard handling
+wxTreeCtrl icon support
+
+wxListCtrl icon support in list mode
+
+================================ MSW ==========================================
+
+Consistent keyboard interface and focus behaviour 
+   currently, the focus is lost all the time (after a MessageBox, for example)
+   and sometimes TABbing through controls doesn't work
+
+================================ GTK  ==========================================
+
+Add support Set colour/baclgroundcolour in GTK widgets
+Correct tab navigation (seems to be a GTK feature)
+Finish DnD
+Add Clipboard
+Help system (not sure about this one)
+Show accelerator in menus
+More controls with bitmaps
+Speed up bitmap saving
+Add wxBitmapHandler
+Fix printing of bitmaps
+Implement wxRadioBox layout
+Finish wxTextCtrl
+Finish native wxTreeCtrl
+Implement wxPalette
+Implement wxDirDialog
+Support cooperation between Qt and wxWindows
+Fix toolbar tips
+TrueType support (just kidding)
+

config.guess

@@ -0,0 +1,599 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright (C) 1992, 93, 94, 95, 1996 Free Software Foundation, Inc.
+#
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Written by Per Bothner <bothner@cygnus.com>.
+# The master version of this file is at the FSF in /home/gd/gnu/lib.
+#
+# This script attempts to guess a canonical system name similar to
+# config.sub.  If it succeeds, it prints the system name on stdout, and
+# exits with 0.  Otherwise, it exits with 1.
+#
+# The plan is that this can be called by configure scripts if you
+# don't specify an explicit system type (host/target name).
+#
+# Only a few systems have been added to this list; please add others
+# (but try to keep the structure clean).
+#
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 8/24/94.)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+	PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+trap 'rm -f dummy.c dummy.o dummy; exit 1' 1 2 15
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    alpha:OSF1:[VX]*:*)
+	# After 1.2, OSF1 uses "V1.3" for uname -r.
+	# After 4.x, OSF1 uses "X4.x" for uname -r.
+	echo alpha-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VX]//'`
+	exit 0 ;;
+    alpha:OSF1:*:*)
+	# 1.2 uses "1.2" for uname -r.
+	echo alpha-dec-osf${UNAME_RELEASE}
+        exit 0 ;;
+    21064:Windows_NT:50:3)
+	echo alpha-dec-winnt3.5
+	exit 0 ;;
+    Amiga*:UNIX_System_V:4.0:*)
+	echo m68k-cbm-sysv4
+	exit 0;;
+    amiga:NetBSD:*:*)
+      echo m68k-cbm-netbsd${UNAME_RELEASE}
+      exit 0 ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+	echo arm-acorn-riscix${UNAME_RELEASE}
+	exit 0;;
+    Pyramid*:OSx*:*:*)
+	if test "`(/bin/universe) 2>/dev/null`" = att ; then
+		echo pyramid-pyramid-sysv3
+	else
+		echo pyramid-pyramid-bsd
+	fi
+	exit 0 ;;
+    sun4*:SunOS:5.*:*)
+	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    i86pc:SunOS:5.*:*)
+	echo i386-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    sun4*:SunOS:6*:*)
+	# According to config.sub, this is the proper way to canonicalize
+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+	# it's likely to be more like Solaris than SunOS4.
+	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    sun4*:SunOS:*:*)
+	case "`/usr/bin/arch -k`" in
+	    Series*|S4*)
+		UNAME_RELEASE=`uname -v`
+		;;
+	esac
+	# Japanese Language versions have a version number like `4.1.3-JL'.
+	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+	exit 0 ;;
+    sun3*:SunOS:*:*)
+	echo m68k-sun-sunos${UNAME_RELEASE}
+	exit 0 ;;
+    atari*:NetBSD:*:*)
+	echo m68k-atari-netbsd${UNAME_RELEASE}
+	exit 0 ;;
+    sun3*:NetBSD:*:*)
+	echo m68k-sun-netbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mac68k:NetBSD:*:*)
+	echo m68k-apple-netbsd${UNAME_RELEASE}
+	exit 0 ;;
+    RISC*:ULTRIX:*:*)
+	echo mips-dec-ultrix${UNAME_RELEASE}
+	exit 0 ;;
+    VAX*:ULTRIX*:*:*)
+	echo vax-dec-ultrix${UNAME_RELEASE}
+	exit 0 ;;
+    mips:*:4*:UMIPS)
+	echo mips-mips-riscos4sysv
+	exit 0 ;;
+    mips:*:5*:RISCos)
+	echo mips-mips-riscos${UNAME_RELEASE}
+	exit 0 ;;
+    Night_Hawk:Power_UNIX:*:*)
+	echo powerpc-harris-powerunix
+	exit 0 ;;
+    m88k:CX/UX:7*:*)
+	echo m88k-harris-cxux7
+	exit 0 ;;
+    m88k:*:4*:R4*)
+	echo m88k-motorola-sysv4
+	exit 0 ;;
+    m88k:*:3*:R3*)
+	echo m88k-motorola-sysv3
+	exit 0 ;;
+    AViiON:dgux:*:*)
+        # DG/UX returns AViiON for all architectures
+        UNAME_PROCESSOR=`uname -p`
+        if [ $UNAME_PROCESSOR = mc88100 -o $UNAME_PROCESSOR = mc88100 ] ; then
+	if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx \
+	     -o ${TARGET_BINARY_INTERFACE}x = x ] ; then
+		echo m88k-dg-dgux${UNAME_RELEASE}
+	else
+		echo m88k-dg-dguxbcs${UNAME_RELEASE}
+	fi
+        else echo i586-dg-dgux${UNAME_RELEASE}
+        fi
+ 	exit 0 ;;
+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
+	echo m88k-dolphin-sysv3
+	exit 0 ;;
+    M88*:*:R3*:*)
+	# Delta 88k system running SVR3
+	echo m88k-motorola-sysv3
+	exit 0 ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+	echo m88k-tektronix-sysv3
+	exit 0 ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+	echo m68k-tektronix-bsd
+	exit 0 ;;
+    *:IRIX*:*:*)
+	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+	exit 0 ;;
+   ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+	echo romp-ibm-aix      # uname -m gives an 8 hex-code CPU id
+	exit 0 ;;              # Note that: echo "'`uname -s`'" gives 'AIX '
+    i[34]86:AIX:*:*)
+	echo i386-ibm-aix
+	exit 0 ;;
+    *:AIX:2:3)
+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		sed 's/^		//' << EOF >dummy.c
+		#include <sys/systemcfg.h>
+
+		main()
+			{
+			if (!__power_pc())
+				exit(1);
+			puts("powerpc-ibm-aix3.2.5");
+			exit(0);
+			}
+EOF
+		${CC-cc} dummy.c -o dummy && ./dummy && rm dummy.c dummy && exit 0
+		rm -f dummy.c dummy
+		echo rs6000-ibm-aix3.2.5
+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+		echo rs6000-ibm-aix3.2.4
+	else
+		echo rs6000-ibm-aix3.2
+	fi
+	exit 0 ;;
+    *:AIX:*:4)
+	if /usr/sbin/lsattr -EHl proc0 | grep POWER >/dev/null 2>&1; then
+		IBM_ARCH=rs6000
+	else
+		IBM_ARCH=powerpc
+	fi
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV=4.${UNAME_RELEASE}
+	fi
+	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+	exit 0 ;;
+    *:AIX:*:*)
+	echo rs6000-ibm-aix
+	exit 0 ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+	echo romp-ibm-bsd4.4
+	exit 0 ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC NetBSD and
+	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to 
+	exit 0 ;;                           # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+	echo rs6000-bull-bosx
+	exit 0 ;;
+    DPX/2?00:B.O.S.:*:*)
+	echo m68k-bull-sysv3
+	exit 0 ;;
+    9000/[34]??:4.3bsd:1.*:*)
+	echo m68k-hp-bsd
+	exit 0 ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+	echo m68k-hp-bsd4.4
+	exit 0 ;;
+    9000/[3478]??:HP-UX:*:*)
+	case "${UNAME_MACHINE}" in
+	    9000/31? )            HP_ARCH=m68000 ;;
+	    9000/[34]?? )         HP_ARCH=m68k ;;
+	    9000/7?? | 9000/8?[679] ) HP_ARCH=hppa1.1 ;;
+	    9000/8?? )            HP_ARCH=hppa1.0 ;;
+	esac
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+	exit 0 ;;
+    3050*:HI-UX:*:*)
+	sed 's/^	//' << EOF >dummy.c
+	#include <unistd.h>
+	int
+	main ()
+	{
+	  long cpu = sysconf (_SC_CPU_VERSION);
+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+	     results, however.  */
+	  if (CPU_IS_PA_RISC (cpu))
+	    {
+	      switch (cpu)
+		{
+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+		  default: puts ("hppa-hitachi-hiuxwe2"); break;
+		}
+	    }
+	  else if (CPU_IS_HP_MC68K (cpu))
+	    puts ("m68k-hitachi-hiuxwe2");
+	  else puts ("unknown-hitachi-hiuxwe2");
+	  exit (0);
+	}
+EOF
+	${CC-cc} dummy.c -o dummy && ./dummy && rm dummy.c dummy && exit 0
+	rm -f dummy.c dummy
+	echo unknown-hitachi-hiuxwe2
+	exit 0 ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+	echo hppa1.1-hp-bsd
+	exit 0 ;;
+    9000/8??:4.3bsd:*:*)
+	echo hppa1.0-hp-bsd
+	exit 0 ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+	echo hppa1.1-hp-osf
+	exit 0 ;;
+    hp8??:OSF1:*:*)
+	echo hppa1.0-hp-osf
+	exit 0 ;;
+    parisc*:Lites*:*:*)
+	echo hppa1.1-hp-lites
+	exit 0 ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+	echo c1-convex-bsd
+        exit 0 ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+        exit 0 ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+	echo c34-convex-bsd
+        exit 0 ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+	echo c38-convex-bsd
+        exit 0 ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+	echo c4-convex-bsd
+        exit 0 ;;
+    CRAY*X-MP:*:*:*)
+	echo xmp-cray-unicos
+        exit 0 ;;
+    CRAY*Y-MP:*:*:*)
+	echo ymp-cray-unicos${UNAME_RELEASE}
+	exit 0 ;;
+    CRAY*C90:*:*:*)
+	echo c90-cray-unicos${UNAME_RELEASE}
+	exit 0 ;;
+    CRAY-2:*:*:*)
+	echo cray2-cray-unicos
+        exit 0 ;;
+    hp3[0-9][05]:NetBSD:*:*)
+	echo m68k-hp-netbsd${UNAME_RELEASE}
+	exit 0 ;;
+    i[34]86:BSD/386:*:* | *:BSD/OS:*:*)
+	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+	exit 0 ;;
+    *:FreeBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+	exit 0 ;;
+    *:NetBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+	exit 0 ;;
+    i*:CYGWIN*:*)
+	echo i386-unknown-cygwin32
+	exit 0 ;;
+    p*:CYGWIN*:*)
+	echo powerpcle-unknown-cygwin32
+	exit 0 ;;
+    *:GNU:*:*)
+	echo `echo ${UNAME_MACHINE}|sed -e 's,/.*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+	exit 0 ;;
+    *:Linux:*:*)
+	# The BFD linker knows what the default object file format is, so
+	# first see if it will tell us.
+	ld_help_string=`ld --help 2>&1`
+	if echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations: elf_i[345]86"; then
+	  echo "${UNAME_MACHINE}-unknown-linux" ; exit 0
+	elif echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations: i[345]86linux"; then
+	  echo "${UNAME_MACHINE}-unknown-linuxaout" ; exit 0
+	elif echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations: i[345]86coff"; then
+	  echo "${UNAME_MACHINE}-unknown-linuxcoff" ; exit 0
+	elif echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations: m68kelf"; then
+	  echo "${UNAME_MACHINE}-unknown-linux" ; exit 0
+	elif echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations: m68klinux"; then
+	  echo "${UNAME_MACHINE}-unknown-linuxaout" ; exit 0
+	elif test "${UNAME_MACHINE}" = "alpha" ; then
+	  echo alpha-unknown-linux ; exit 0
+	else
+	  # Either a pre-BFD a.out linker (linuxoldld) or one that does not give us
+	  # useful --help.  Gcc wants to distinguish between linuxoldld and linuxaout.
+	  test ! -d /usr/lib/ldscripts/. \
+	    && echo "${UNAME_MACHINE}-unknown-linuxoldld" && exit 0
+	  # Determine whether the default compiler is a.out or elf
+	  cat >dummy.c <<EOF
+main(argc, argv)
+int argc;
+char *argv[];
+{
+#ifdef __ELF__
+  printf ("%s-unknown-linux\n", argv[1]);
+#else
+  printf ("%s-unknown-linuxaout\n", argv[1]);
+#endif
+  return 0;
+}
+EOF
+	  ${CC-cc} dummy.c -o dummy 2>/dev/null && ./dummy "${UNAME_MACHINE}" && rm dummy.c dummy && exit 0
+	  rm -f dummy.c dummy
+	fi ;;
+# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
+# are messed up and put the nodename in both sysname and nodename.
+    i[34]86:DYNIX/ptx:4*:*)
+	echo i386-sequent-sysv4
+	exit 0 ;;
+    i[34]86:*:4.*:* | i[34]86:SYSTEM_V:4.*:*)
+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+		echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE}
+	else
+		echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}
+	fi
+	exit 0 ;;
+    i[34]86:*:3.2:*)
+	if test -f /usr/options/cb.name; then
+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+		echo ${UNAME_MACHINE}-unknown-isc$UNAME_REL
+	elif /bin/uname -X 2>/dev/null >/dev/null ; then
+		UNAME_REL=`(/bin/uname -X|egrep Release|sed -e 's/.*= //')`
+		(/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486
+		(/bin/uname -X|egrep '^Machine.*Pentium' >/dev/null) \
+			&& UNAME_MACHINE=i586
+		echo ${UNAME_MACHINE}-unknown-sco$UNAME_REL
+	else
+		echo ${UNAME_MACHINE}-unknown-sysv32
+	fi
+	exit 0 ;;
+    Intel:Mach:3*:*)
+	echo i386-unknown-mach3
+	exit 0 ;;
+    paragon:*:*:*)
+	echo i860-intel-osf1
+	exit 0 ;;
+    i860:*:4.*:*) # i860-SVR4
+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+	else # Add other i860-SVR4 vendors below as they are discovered.
+	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+	fi
+	exit 0 ;;
+    mini*:CTIX:SYS*5:*)
+	# "miniframe"
+	echo m68010-convergent-sysv
+	exit 0 ;;
+    M680[234]0:*:R3V[567]*:*)
+	test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
+    3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0)
+        uname -p 2>/dev/null | grep 86 >/dev/null \
+          && echo i486-ncr-sysv4.3 && exit 0 ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+        uname -p 2>/dev/null | grep 86 >/dev/null \
+          && echo i486-ncr-sysv4 && exit 0 ;;
+    m680[234]0:LynxOS:2.[23]*:*)
+	echo m68k-lynx-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    mc68030:UNIX_System_V:4.*:*)
+	echo m68k-atari-sysv4
+	exit 0 ;;
+    i[34]86:LynxOS:2.[23]*:*)
+	echo i386-lynx-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    TSUNAMI:LynxOS:2.[23]*:*)
+	echo sparc-lynx-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    rs6000:LynxOS:2.[23]*:*)
+	echo rs6000-lynx-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    RM*:SINIX-*:*:*)
+	echo mips-sni-sysv4
+	exit 0 ;;
+    *:SINIX-*:*:*)
+	if uname -p 2>/dev/null >/dev/null ; then
+		UNAME_MACHINE=`(uname -p) 2>/dev/null`
+		echo ${UNAME_MACHINE}-sni-sysv4
+	else
+		echo ns32k-sni-sysv
+	fi
+	exit 0 ;;
+    mc68*:A/UX:*:*)
+	echo m68k-apple-aux${UNAME_RELEASE}
+	exit 0 ;;
+    R3000:*System_V*:*:*)
+	if [ -d /usr/nec ]; then
+	        echo mips-nec-sysv${UNAME_RELEASE}
+	else
+	        echo mips-unknown-sysv${UNAME_RELEASE}
+	fi
+        exit 0 ;;
+esac
+
+#echo '(No uname command or uname output not recognized.)' 1>&2
+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
+
+cat >dummy.c <<EOF
+#ifdef _SEQUENT_
+# include <sys/types.h>
+# include <sys/utsname.h>
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
+     I don't know....  */
+  printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+  printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+          "4"
+#else
+	  ""
+#endif
+         ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+  printf ("arm-acorn-riscix"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+  printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+  int version;
+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+  printf ("%s-next-nextstep%s\n", __ARCHITECTURE__,  version==2 ? "2" : "3");
+  exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+  printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+  printf ("ns32k-encore-mach\n"); exit (0);
+#else
+  printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+  printf ("i386-unknown-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+  printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+  printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+    struct utsname un;
+
+    uname(&un);
+
+    if (strncmp(un.version, "V2", 2) == 0) {
+	printf ("i386-sequent-ptx2\n"); exit (0);
+    }
+    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+	printf ("i386-sequent-ptx1\n"); exit (0);
+    }
+    printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+#if !defined (ultrix)
+  printf ("vax-dec-bsd\n"); exit (0);
+#else
+  printf ("vax-dec-ultrix\n"); exit (0);
+#endif
+#endif
+
+#if defined (alliant) && defined (i860)
+  printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+  exit (1);
+}
+EOF
+
+${CC-cc} dummy.c -o dummy 2>/dev/null && ./dummy && rm dummy.c dummy && exit 0
+rm -f dummy.c dummy
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+    case `getsysinfo -f cpu_type` in
+    c1*)
+	echo c1-convex-bsd
+	exit 0 ;;
+    c2*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+	exit 0 ;;
+    c34*)
+	echo c34-convex-bsd
+	exit 0 ;;
+    c38*)
+	echo c38-convex-bsd
+	exit 0 ;;
+    c4*)
+	echo c4-convex-bsd
+	exit 0 ;;
+    esac
+fi
+
+#echo '(Unable to guess system type)' 1>&2
+
+exit 1

config.sub

@@ -0,0 +1,927 @@
+#! /bin/sh
+# Configuration validation subroutine script, version 1.1.
+#   Copyright (C) 1991, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+if [ x$1 = x ]
+then
+	echo Configuration name missing. 1>&2
+	echo "Usage: $0 CPU-MFR-OPSYS" 1>&2
+	echo "or     $0 ALIAS" 1>&2
+	echo where ALIAS is a recognized configuration type. 1>&2
+	exit 1
+fi
+
+# First pass through any local machine types.
+case $1 in
+	*local*)
+		echo $1
+		exit 0
+		;;
+	*)
+	;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  linux-gnu*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+	-sun*os*)
+		# Prevent following clause from handling this invalid input.
+		;;
+	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+	-apple)
+		os=
+		basic_machine=$1
+		;;
+	-hiux*)
+		os=-hiuxwe2
+		;;
+	-sco5)
+		os=sco3.2v5
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco4)
+		os=-sco3.2v4
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2.[4-9]*)
+		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2v[4-9]*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco*)
+		os=-sco3.2v2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-isc)
+		os=-isc2.2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-clix*)
+		basic_machine=clipper-intergraph
+		;;
+	-isc*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-lynx*)
+		os=-lynxos
+		;;
+	-ptx*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+		;;
+	-windowsnt*)
+		os=`echo $os | sed -e 's/windowsnt/winnt/'`
+		;;
+	-psos*)
+		os=-psos
+		;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+	# Recognize the basic CPU types without company name.
+	# Some are omitted here because they have special meanings below.
+	tahoe | i860 | m68k | m68000 | m88k | ns32k | arm \
+		| arme[lb] | pyramid \
+		| tron | a29k | 580 | i960 | h8300 | hppa | hppa1.0 | hppa1.1 \
+		| alpha | we32k | ns16k | clipper | i370 | sh \
+		| powerpc | powerpcle | 1750a | dsp16xx | mips64 | mipsel \
+		| pdp11 | mips64el | mips64orion | mips64orionel \
+		| sparc | sparclet | sparclite | sparc64)
+		basic_machine=$basic_machine-unknown
+		;;
+	# We use `pc' rather than `unknown'
+	# because (1) that's what they normally are, and
+	# (2) the word "unknown" tends to confuse beginning users.
+	i[3456]86)
+	  basic_machine=$basic_machine-pc
+	  ;;
+	# Object if more than one company name word.
+	*-*-*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+	# Recognize the basic CPU types with company name.
+	vax-* | tahoe-* | i[3456]86-* | i860-* | m68k-* | m68000-* | m88k-* \
+	      | sparc-* | ns32k-* | fx80-* | arm-* | c[123]* \
+	      | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* | power-* \
+	      | none-* | 580-* | cray2-* | h8300-* | i960-* | xmp-* | ymp-* \
+	      | hppa-* | hppa1.0-* | hppa1.1-* | alpha-* | we32k-* | cydra-* | ns16k-* \
+	      | pn-* | np1-* | xps100-* | clipper-* | orion-* | sparclite-* \
+	      | pdp11-* | sh-* | powerpc-* | powerpcle-* | sparc64-* | mips64-* | mipsel-* \
+	      | mips64el-* | mips64orion-* | mips64orionel-* | f301-*)
+		;;
+	# Recognize the various machine names and aliases which stand
+	# for a CPU type and a company and sometimes even an OS.
+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+		basic_machine=m68000-att
+		;;
+	3b*)
+		basic_machine=we32k-att
+		;;
+	alliant | fx80)
+		basic_machine=fx80-alliant
+		;;
+	altos | altos3068)
+		basic_machine=m68k-altos
+		;;
+	am29k)
+		basic_machine=a29k-none
+		os=-bsd
+		;;
+	amdahl)
+		basic_machine=580-amdahl
+		os=-sysv
+		;;
+	amiga | amiga-*)
+		basic_machine=m68k-cbm
+		;;
+	amigados)
+		basic_machine=m68k-cbm
+		os=-amigados
+		;;
+	amigaunix | amix)
+		basic_machine=m68k-cbm
+		os=-sysv4
+		;;
+	apollo68)
+		basic_machine=m68k-apollo
+		os=-sysv
+		;;
+	aux)
+		basic_machine=m68k-apple
+		os=-aux
+		;;
+	balance)
+		basic_machine=ns32k-sequent
+		os=-dynix
+		;;
+	convex-c1)
+		basic_machine=c1-convex
+		os=-bsd
+		;;
+	convex-c2)
+		basic_machine=c2-convex
+		os=-bsd
+		;;
+	convex-c32)
+		basic_machine=c32-convex
+		os=-bsd
+		;;
+	convex-c34)
+		basic_machine=c34-convex
+		os=-bsd
+		;;
+	convex-c38)
+		basic_machine=c38-convex
+		os=-bsd
+		;;
+	cray | ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
+	cray2)
+		basic_machine=cray2-cray
+		os=-unicos
+		;;
+	[ctj]90-cray)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
+	crds | unos)
+		basic_machine=m68k-crds
+		;;
+	da30 | da30-*)
+		basic_machine=m68k-da30
+		;;
+	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+		basic_machine=mips-dec
+		;;
+	delta | 3300 | motorola-3300 | motorola-delta \
+	      | 3300-motorola | delta-motorola)
+		basic_machine=m68k-motorola
+		;;
+	delta88)
+		basic_machine=m88k-motorola
+		os=-sysv3
+		;;
+	dpx20 | dpx20-*)
+		basic_machine=rs6000-bull
+		os=-bosx
+		;;
+	dpx2* | dpx2*-bull)
+		basic_machine=m68k-bull
+		os=-sysv3
+		;;
+	ebmon29k)
+		basic_machine=a29k-amd
+		os=-ebmon
+		;;
+	elxsi)
+		basic_machine=elxsi-elxsi
+		os=-bsd
+		;;
+	encore | umax | mmax)
+		basic_machine=ns32k-encore
+		;;
+	fx2800)
+		basic_machine=i860-alliant
+		;;
+	genix)
+		basic_machine=ns32k-ns
+		;;
+	gmicro)
+		basic_machine=tron-gmicro
+		os=-sysv
+		;;
+	h3050r* | hiux*)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	h8300hms)
+		basic_machine=h8300-hitachi
+		os=-hms
+		;;
+	harris)
+		basic_machine=m88k-harris
+		os=-sysv3
+		;;
+	hp300-*)
+		basic_machine=m68k-hp
+		;;
+	hp300bsd)
+		basic_machine=m68k-hp
+		os=-bsd
+		;;
+	hp300hpux)
+		basic_machine=m68k-hp
+		os=-hpux
+		;;
+	hp9k2[0-9][0-9] | hp9k31[0-9])
+		basic_machine=m68000-hp
+		;;
+	hp9k3[2-9][0-9])
+		basic_machine=m68k-hp
+		;;
+	hp9k7[0-9][0-9] | hp7[0-9][0-9] | hp9k8[0-9]7 | hp8[0-9]7)
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][0-9] | hp8[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hppa-next)
+		os=-nextstep3
+		;;
+	i370-ibm* | ibm*)
+		basic_machine=i370-ibm
+		os=-mvs
+		;;
+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
+	i[3456]86v32)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv32
+		;;
+	i[3456]86v4*)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv4
+		;;
+	i[3456]86v)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv
+		;;
+	i[3456]86sol2)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-solaris2
+		;;
+	iris | iris4d)
+		basic_machine=mips-sgi
+		case $os in
+		    -irix*)
+			;;
+		    *)
+			os=-irix4
+			;;
+		esac
+		;;
+	isi68 | isi)
+		basic_machine=m68k-isi
+		os=-sysv
+		;;
+	m88k-omron*)
+		basic_machine=m88k-omron
+		;;
+	magnum | m3230)
+		basic_machine=mips-mips
+		os=-sysv
+		;;
+	merlin)
+		basic_machine=ns32k-utek
+		os=-sysv
+		;;
+	miniframe)
+		basic_machine=m68000-convergent
+		;;
+	mips3*-*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+		;;
+	mips3*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+		;;
+	ncr3000)
+		basic_machine=i486-ncr
+		os=-sysv4
+		;;
+	news | news700 | news800 | news900)
+		basic_machine=m68k-sony
+		os=-newsos
+		;;
+	news1000)
+		basic_machine=m68030-sony
+		os=-newsos
+		;;
+	news-3600 | risc-news)
+		basic_machine=mips-sony
+		os=-newsos
+		;;
+	next | m*-next )
+		basic_machine=m68k-next
+		case $os in
+		    -nextstep* )
+			;;
+		    -ns2*)
+		      os=-nextstep2
+			;;
+		    *)
+		      os=-nextstep3
+			;;
+		esac
+		;;
+	nh3000)
+		basic_machine=m68k-harris
+		os=-cxux
+		;;
+	nh[45]000)
+		basic_machine=m88k-harris
+		os=-cxux
+		;;
+	nindy960)
+		basic_machine=i960-intel
+		os=-nindy
+		;;
+	np1)
+		basic_machine=np1-gould
+		;;
+	pa-hitachi)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	paragon)
+		basic_machine=i860-intel
+		os=-osf
+		;;
+	pbd)
+		basic_machine=sparc-tti
+		;;
+	pbb)
+		basic_machine=m68k-tti
+		;;
+        pc532 | pc532-*)
+		basic_machine=ns32k-pc532
+		;;
+	pentium | p5)
+		basic_machine=i586-intel
+		;;
+	pentiumpro | p6)
+		basic_machine=i686-intel
+		;;
+	pentium-* | p5-*)
+		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumpro-* | p6-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	k5)
+		# We don't have specific support for AMD's K5 yet, so just call it a Pentium
+		basic_machine=i586-amd
+		;;
+	nexen)
+		# We don't have specific support for Nexgen yet, so just call it a Pentium
+		basic_machine=i586-nexgen
+		;;
+	pn)
+		basic_machine=pn-gould
+		;;
+	power)	basic_machine=rs6000-ibm
+		;;
+	ppc)	basic_machine=powerpc-unknown
+	        ;;
+	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppcle | powerpclittle | ppc-le | powerpc-little)
+		basic_machine=powerpcle-unknown
+	        ;;
+	ppcle-* | powerpclittle-*)
+		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ps2)
+		basic_machine=i386-ibm
+		;;
+	rm[46]00)
+		basic_machine=mips-siemens
+		;;
+	rtpc | rtpc-*)
+		basic_machine=romp-ibm
+		;;
+	sequent)
+		basic_machine=i386-sequent
+		;;
+	sh)
+		basic_machine=sh-hitachi
+		os=-hms
+		;;
+	sps7)
+		basic_machine=m68k-bull
+		os=-sysv2
+		;;
+	spur)
+		basic_machine=spur-unknown
+		;;
+	sun2)
+		basic_machine=m68000-sun
+		;;
+	sun2os3)
+		basic_machine=m68000-sun
+		os=-sunos3
+		;;
+	sun2os4)
+		basic_machine=m68000-sun
+		os=-sunos4
+		;;
+	sun3os3)
+		basic_machine=m68k-sun
+		os=-sunos3
+		;;
+	sun3os4)
+		basic_machine=m68k-sun
+		os=-sunos4
+		;;
+	sun4os3)
+		basic_machine=sparc-sun
+		os=-sunos3
+		;;
+	sun4os4)
+		basic_machine=sparc-sun
+		os=-sunos4
+		;;
+	sun4sol2)
+		basic_machine=sparc-sun
+		os=-solaris2
+		;;
+	sun3 | sun3-*)
+		basic_machine=m68k-sun
+		;;
+	sun4)
+		basic_machine=sparc-sun
+		;;
+	sun386 | sun386i | roadrunner)
+		basic_machine=i386-sun
+		;;
+	symmetry)
+		basic_machine=i386-sequent
+		os=-dynix
+		;;
+	tower | tower-32)
+		basic_machine=m68k-ncr
+		;;
+	udi29k)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	ultra3)
+		basic_machine=a29k-nyu
+		os=-sym1
+		;;
+	vaxv)
+		basic_machine=vax-dec
+		os=-sysv
+		;;
+	vms)
+		basic_machine=vax-dec
+		os=-vms
+		;;
+       vpp*|vx|vx-*)
+               basic_machine=f301-fujitsu
+               ;;
+	vxworks960)
+		basic_machine=i960-wrs
+		os=-vxworks
+		;;
+	vxworks68)
+		basic_machine=m68k-wrs
+		os=-vxworks
+		;;
+	vxworks29k)
+		basic_machine=a29k-wrs
+		os=-vxworks
+		;;
+	xmp)
+		basic_machine=xmp-cray
+		os=-unicos
+		;;
+        xps | xps100)
+		basic_machine=xps100-honeywell
+		;;
+	none)
+		basic_machine=none-none
+		os=-none
+		;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+	mips)
+		basic_machine=mips-mips
+		;;
+	romp)
+		basic_machine=romp-ibm
+		;;
+	rs6000)
+		basic_machine=rs6000-ibm
+		;;
+	vax)
+		basic_machine=vax-dec
+		;;
+	pdp11)
+		basic_machine=pdp11-dec
+		;;
+	we32k)
+		basic_machine=we32k-att
+		;;
+	sparc)
+		basic_machine=sparc-sun
+		;;
+        cydra)
+		basic_machine=cydra-cydrome
+		;;
+	orion)
+		basic_machine=orion-highlevel
+		;;
+	orion105)
+		basic_machine=clipper-highlevel
+		;;
+	*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+	*-digital*)
+		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+		;;
+	*-commodore*)
+		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+		;;
+	*)
+		;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+        # First match some system type aliases
+        # that might get confused with valid system types.
+	# -solaris* is a basic system type, with this one exception.
+	-solaris1 | -solaris1.*)
+		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+		;;
+	-solaris)
+		os=-solaris2
+		;;
+	-unixware* | svr4*)
+		os=-sysv4
+		;;
+	-gnu/linux*)
+		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+		;;
+	# First accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST END IN A *, to match a version number.
+	# -sysv* is not here because it comes later, after sysvr4.
+	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+	      | -amigados* | -msdos* | -newsos* | -unicos* | -aof* | -aos* \
+	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+	      | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \
+	      | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* \
+	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -cygwin32* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -linux-gnu* | -uxpv*)
+	# Remember, each alternative MUST END IN *, to match a version number.
+		;;
+	-linux*)
+		os=`echo $os | sed -e 's|linux|linux-gnu|'`
+		;;
+	-sunos5*)
+		os=`echo $os | sed -e 's|sunos5|solaris2|'`
+		;;
+	-sunos6*)
+		os=`echo $os | sed -e 's|sunos6|solaris3|'`
+		;;
+	-osfrose*)
+		os=-osfrose
+		;;
+	-osf*)
+		os=-osf
+		;;
+	-utek*)
+		os=-bsd
+		;;
+	-dynix*)
+		os=-bsd
+		;;
+	-acis*)
+		os=-aos
+		;;
+	-ctix* | -uts*)
+		os=-sysv
+		;;
+	-ns2 )
+	        os=-nextstep2
+		;;
+	# Preserve the version number of sinix5.
+	-sinix5.*)
+		os=`echo $os | sed -e 's|sinix|sysv|'`
+		;;
+	-sinix*)
+		os=-sysv4
+		;;
+	-triton*)
+		os=-sysv3
+		;;
+	-oss*)
+		os=-sysv3
+		;;
+	-svr4)
+		os=-sysv4
+		;;
+	-svr3)
+		os=-sysv3
+		;;
+	-sysvr4)
+		os=-sysv4
+		;;
+	# This must come after -sysvr4.
+	-sysv*)
+		;;
+	-xenix)
+		os=-xenix
+		;;
+	-none)
+		;;
+	*)
+		# Get rid of the `-' at the beginning of $os.
+		os=`echo $os | sed 's/[^-]*-//'`
+		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+		exit 1
+		;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+	*-acorn)
+		os=-riscix1.2
+		;;
+	arm*-semi)
+		os=-aout
+		;;
+        pdp11-*)
+		os=-none
+		;;
+	*-dec | vax-*)
+		os=-ultrix4.2
+		;;
+	m68*-apollo)
+		os=-domain
+		;;
+	i386-sun)
+		os=-sunos4.0.2
+		;;
+	m68000-sun)
+		os=-sunos3
+		# This also exists in the configure program, but was not the
+		# default.
+		# os=-sunos4
+		;;
+	*-tti)	# must be before sparc entry or we get the wrong os.
+		os=-sysv3
+		;;
+	sparc-* | *-sun)
+		os=-sunos4.1.1
+		;;
+	*-ibm)
+		os=-aix
+		;;
+	*-hp)
+		os=-hpux
+		;;
+	*-hitachi)
+		os=-hiux
+		;;
+	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+		os=-sysv
+		;;
+	*-cbm)
+		os=-amigados
+		;;
+	*-dg)
+		os=-dgux
+		;;
+	*-dolphin)
+		os=-sysv3
+		;;
+	m68k-ccur)
+		os=-rtu
+		;;
+	m88k-omron*)
+		os=-luna
+		;;
+	*-next )
+		os=-nextstep
+		;;
+	*-sequent)
+		os=-ptx
+		;;
+	*-crds)
+		os=-unos
+		;;
+	*-ns)
+		os=-genix
+		;;
+	i370-*)
+		os=-mvs
+		;;
+	*-next)
+		os=-nextstep3
+		;;
+        *-gould)
+		os=-sysv
+		;;
+        *-highlevel)
+		os=-bsd
+		;;
+	*-encore)
+		os=-bsd
+		;;
+        *-sgi)
+		os=-irix
+		;;
+        *-siemens)
+		os=-sysv4
+		;;
+	*-masscomp)
+		os=-rtu
+		;;
+	f301-fujitsu)
+		os=-uxpv
+		;;
+	*)
+		os=-none
+		;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+	*-unknown)
+		case $os in
+			-riscix*)
+				vendor=acorn
+				;;
+			-sunos*)
+				vendor=sun
+				;;
+			-aix*)
+				vendor=ibm
+				;;
+			-hpux*)
+				vendor=hp
+				;;
+			-hiux*)
+				vendor=hitachi
+				;;
+			-unos*)
+				vendor=crds
+				;;
+			-dgux*)
+				vendor=dg
+				;;
+			-luna*)
+				vendor=omron
+				;;
+			-genix*)
+				vendor=ns
+				;;
+			-mvs*)
+				vendor=ibm
+				;;
+			-ptx*)
+				vendor=sequent
+				;;
+			-vxsim* | -vxworks*)
+				vendor=wrs
+				;;
+			-aux*)
+				vendor=apple
+				;;
+		esac
+		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+		;;
+esac
+
+echo $basic_machine$os

distrib/msw/docsrc.rsp

@@ -0,0 +1,85 @@
+docs/latex/wx/*.tex
+docs/latex/wx/*.sty
+docs/latex/wx/*.bib
+docs/latex/wx/*.hpj
+docs/latex/wx/*.ini
+docs/latex/wx/*.txt
+docs/latex/wx/*.cnt
+docs/latex/wx/*.eps
+docs/latex/wx/*.bmp
+docs/latex/wx/*.gif
+docs/latex/wx/*.wmf
+
+docs/latex/porting/*.tex
+docs/latex/porting/*.sty
+docs/latex/porting/*.bib
+docs/latex/porting/*.hpj
+docs/latex/porting/*.ini
+docs/latex/porting/*.txt
+docs/latex/porting/*.cnt
+docs/latex/porting/*.eps
+docs/latex/porting/*.gif
+docs/latex/porting/*.bmp
+
+utils/wxhelp/docs/*.tex
+utils/wxhelp/docs/*.txt
+utils/wxhelp/docs/*.hpj
+utils/wxhelp/docs/*.ini
+utils/wxhelp/docs/*.bmp
+utils/wxhelp/docs/*.wmf
+utils/wxhelp/docs/*.gif
+
+utils/tex2rtf/docs/*.tex
+utils/tex2rtf/docs/*.txt
+utils/tex2rtf/docs/*.hpj
+utils/tex2rtf/docs/*.bib
+utils/tex2rtf/docs/*.ini
+utils/tex2rtf/docs/*.sty
+utils/tex2rtf/docs/*.bmp
+utils/tex2rtf/docs/*.shg
+utils/tex2rtf/docs/*.wmf
+utils/tex2rtf/docs/*.gif
+
+utils/wxtree/docs/*.tex
+utils/wxtree/docs/*.ini
+utils/wxtree/docs/*.bib
+utils/wxtree/docs/*.txt
+utils/wxtree/docs/*.hpj
+utils/wxtree/docs/*.bmp
+utils/wxtree/docs/*.wmf
+utils/wxtree/docs/*.gif
+
+utils/wxgraph/docs/*.tex
+utils/wxgraph/docs/*.ini
+utils/wxgraph/docs/*.bib
+utils/wxgraph/docs/*.txt
+utils/wxgraph/docs/*.hpj
+utils/wxgraph/docs/*.bmp
+utils/wxgraph/docs/*.wmf
+utils/wxgraph/docs/*.gif
+
+utils/mfutils/docs/*.tex
+utils/mfutils/docs/*.txt
+utils/mfutils/docs/*.hpj
+utils/mfutils/docs/*.wmf
+utils/mfutils/docs/*.bmp
+
+utils/wxprop/docs/*.txt
+utils/wxprop/docs/*.hpj
+utils/wxprop/docs/*.tex
+utils/wxprop/docs/*.ini
+utils/wxprop/docs/*.eps
+utils/wxprop/docs/*.bmp
+utils/wxprop/docs/*.wmf
+utils/wxprop/docs/*.gif
+
+utils/dialoged/docs/*.txt
+utils/dialoged/docs/*.hpj
+utils/dialoged/docs/*.tex
+utils/dialoged/docs/*.ini
+utils/dialoged/docs/*.eps
+utils/dialoged/docs/*.bmp
+utils/dialoged/docs/*.wmf
+utils/dialoged/docs/*.gif
+
+

distrib/msw/generic.rsp

@@ -0,0 +1,699 @@
+distrib/msw/*.rsp
+distrib/msw/*.bat
+
+docs/readme.txt
+docs/install.txt
+docs/release.txt
+docs/changes.txt
+docs/upgrade.txt
+docs/todo.txt
+docs/licence.txt
+docs/symbols.txt
+docs/*.html
+
+src/*.inc
+src/mkdir
+
+src/common/*.cpp
+src/common/dosyacc.c
+src/common/doslex.c
+src/common/vmsyacc.c
+src/common/vmslex.c
+src/common/extended.c
+src/common/*.l
+src/common/*.y
+src/common/*.inc
+
+src/generic/*.cpp
+src/generic/*.c
+src/generic/*.inc
+
+src/png/*.c
+src/png/*.h
+src/png/makefile*
+src/png/INSTALL
+src/png/CHANGES
+src/png/README
+src/png/TODO
+src/png/*.1
+src/png/*.3
+src/png/*.5
+src/png/scripts/*
+
+src/zlib/*.c
+src/zlib/*.h
+src/zlib/INDEX
+src/zlib/README
+src/zlib/ChangeLog
+src/zlib/configure
+src/zlib/*.txt
+src/zlib/makefile*
+src/zlib/*.com
+src/zlib/*.3
+src/zlib/*.mms
+
+include/wx/*.h
+include/wx/protocol/*.h
+include/wx/*.cpp
+include/wx/wx_setup.vms
+include/wx/common/*.h
+include/wx/generic/*.h
+lib/dummy
+
+bin/*.*
+
+tools/gettext/*.*
+
+bitmaps/xpm/16x16/*.*
+bitmaps/xpm/32x32/*.*
+bitmaps/xpm/64x64/*.*
+bitmaps/xpm/misc/*.*
+bitmaps/*.*
+bitmaps/bmp/16x15/*.*
+bitmaps/bmp/10x8/*.*
+bitmaps/ico/32x32/*.*
+
+afm/*.*
+
+utils/*.txt
+utils/make*
+
+utils/xpmshow/src/makefile*
+utils/xpmshow/src/*.cpp
+utils/xpmshow/src/*.h
+utils/xpmshow/src/*.def
+utils/xpmshow/src/*.rc
+utils/xpmshow/src/*.xpm
+utils/xpmshow/src/*.bmp
+utils/xpmshow/src/*.ico
+
+utils/wxhelp/src/*.cpp
+utils/wxhelp/src/*.h
+utils/wxhelp/src/makefile*
+utils/wxhelp/src/*.xbm
+utils/wxhelp/src/*.xpm
+utils/wxhelp/src/*.txt
+utils/wxhelp/src/*.ico
+utils/wxhelp/src/*.def
+utils/wxhelp/src/*.rc
+
+utils/tex2rtf/src/wxwin/*.*
+utils/tex2rtf/src/*.cpp
+utils/tex2rtf/src/*.h
+utils/tex2rtf/src/make*.*
+utils/tex2rtf/src/*.xbm
+utils/tex2rtf/src/*.xpm
+utils/tex2rtf/src/*.sty
+utils/tex2rtf/src/*.ini
+utils/tex2rtf/src/*.inf
+utils/tex2rtf/lib/dummy
+utils/tex2rtf/src/*.bmp
+utils/tex2rtf/src/*.ico
+utils/tex2rtf/src/*.def
+utils/tex2rtf/src/*.rc
+utils/tex2rtf/tools/lacheck/*.*
+utils/tex2rtf/tools/tcheck/*.awk
+utils/tex2rtf/tools/tcheck/*.pl
+utils/tex2rtf/tools/tcheck/*.bat
+
+utils/wxtree/src/*.cpp
+utils/wxtree/src/*.h
+utils/wxtree/src/makefile*
+utils/wxtree/src/*.xbm
+utils/wxtree/src/*.xpm
+utils/wxtree/lib/dummy
+utils/wxtree/src/*.ico
+utils/wxtree/src/*.def
+utils/wxtree/src/*.rc
+
+utils/wxgraph/src/*.cpp
+utils/wxgraph/src/*.c
+utils/wxgraph/src/*.h
+utils/wxgraph/src/makefile*
+utils/wxgraph/src/*.xbm
+utils/wxgraph/src/*.xpm
+utils/wxgraph/lib/dummy
+utils/wxgraph/src/*.ico
+utils/wxgraph/src/*.def
+utils/wxgraph/src/*.rc
+
+utils/mfutils/src/*.cpp
+utils/mfutils/src/*.h
+utils/mfutils/src/*.rc
+utils/mfutils/src/*.def
+utils/mfutils/src/makefile*
+utils/mfutils/src/*.txt
+utils/mfutils/lib/dummy
+utils/mfutils/src/*.ico
+utils/mfutils/src/*.def
+utils/mfutils/src/*.bmp
+utils/mfutils/src/*.ico
+
+utils/rcparser/src/*.cpp
+utils/rcparser/src/*.c
+utils/rcparser/src/*.h
+utils/rcparser/src/makefile*
+utils/rcparser/src/*.xbm
+utils/rcparser/src/*.xpm
+utils/rcparser/lib/dummy
+utils/rcparser/src/*.ico
+utils/rcparser/src/*.def
+utils/rcparser/src/*.rc
+utils/rcparser/src/*.rh
+
+utils/colours/*.h
+utils/colours/*.cpp
+utils/colours/*.def
+utils/colours/*.rc
+utils/colours/makefile*
+utils/colours/*.xbm
+utils/colours/*.xpm
+utils/colours/*.txt
+
+utils/serialize/*.h
+utils/serialize/*.cpp
+utils/serialize/*.def
+utils/serialize/*.rc
+utils/serialize/makefile*
+utils/serialize/*.xbm
+utils/serialize/*.xpm
+utils/serialize/*.txt
+
+utils/wxprop/Makefile
+utils/wxprop/src/*.h
+utils/wxprop/src/*.cpp
+utils/wxprop/src/*.def
+utils/wxprop/src/*.rc
+utils/wxprop/src/makefile*
+utils/wxprop/src/*.xbm
+utils/wxprop/src/*.xpm
+utils/wxprop/src/*.txt
+utils/wxprop/src/*.ico
+utils/wxprop/src/*.bmp
+utils/wxprop/lib/dummy
+
+utils/dialoged/Makefile
+utils/dialoged/src/bitmaps/*.xbm
+utils/dialoged/src/bitmaps/*.xpm
+utils/dialoged/src/*.h
+utils/dialoged/src/*.cpp
+utils/dialoged/src/*.def
+utils/dialoged/src/*.rc
+utils/dialoged/src/makefile*
+utils/dialoged/src/*.xbm
+utils/dialoged/src/*.xpm
+utils/dialoged/src/*.txt
+utils/dialoged/src/*.inf
+utils/dialoged/test/*.h
+utils/dialoged/src/*.ico
+utils/dialoged/src/*.prj
+utils/dialoged/src/*.bmp
+utils/dialoged/src/bitmaps/*.bmp
+utils/dialoged/src/bitmaps/*.ico
+utils/dialoged/test/*.cpp
+utils/dialoged/test/*.def
+utils/dialoged/test/*.rc
+utils/dialoged/test/makefile*
+utils/dialoged/lib/dummy
+utils/dialoged/test/*.ico
+utils/dialoged/test/*.prj
+utils/dialoged/test/*.bmp
+
+utils/glcanvas/Makefile
+utils/glcanvas/win/*.h
+utils/glcanvas/win/*.cpp
+utils/glcanvas/win/*.def
+utils/glcanvas/win/*.rc
+utils/glcanvas/win/makefile*
+utils/glcanvas/win/*.xbm
+utils/glcanvas/win/*.xpm
+utils/glcanvas/win/*.txt
+utils/glcanvas/win/*.ico
+utils/glcanvas/win/*.bmp
+utils/glcanvas/src/*.h
+utils/glcanvas/src/*.cpp
+utils/glcanvas/src/*.def
+utils/glcanvas/src/*.rc
+utils/glcanvas/src/makefile*
+utils/glcanvas/src/*.xbm
+utils/glcanvas/src/*.xpm
+utils/glcanvas/src/*.txt
+utils/glcanvas/src/*.ico
+utils/glcanvas/src/*.bmp
+utils/glcanvas/samples/cube/*.h
+utils/glcanvas/samples/cube/*.cpp
+utils/glcanvas/samples/cube/*.def
+utils/glcanvas/samples/cube/*.rc
+utils/glcanvas/samples/cube/makefile*
+utils/glcanvas/samples/cube/*.xbm
+utils/glcanvas/samples/cube/*.xpm
+utils/glcanvas/samples/cube/*.txt
+utils/glcanvas/samples/cube/*.ico
+utils/glcanvas/samples/cube/*.bmp
+utils/glcanvas/samples/isosurf/*.h
+utils/glcanvas/samples/isosurf/*.cpp
+utils/glcanvas/samples/isosurf/*.def
+utils/glcanvas/samples/isosurf/*.rc
+utils/glcanvas/samples/isosurf/makefile*
+utils/glcanvas/samples/isosurf/*.xbm
+utils/glcanvas/samples/isosurf/*.xpm
+utils/glcanvas/samples/isosurf/*.txt
+utils/glcanvas/samples/isosurf/*.ico
+utils/glcanvas/samples/isosurf/*.bmp
+utils/glcanvas/samples/isosurf/*.gz
+utils/glcanvas/docs/*.tex
+utils/glcanvas/docs/*.txt
+utils/glcanvas/docs/*.bmp
+utils/glcanvas/docs/*.gif
+
+samples/*.txt
+samples/makefile*
+
+samples/config/*.cpp
+samples/config/*.h
+samples/config/*.def
+samples/config/makefile*
+samples/config/*.xbm
+samples/config/*.xpm
+samples/config/*.txt
+samples/config/*.ico
+samples/config/*.bmp
+samples/config/*.rc
+samples/config/*.wav
+
+samples/dynamic/*.cpp
+samples/dynamic/*.h
+samples/dynamic/*.def
+samples/dynamic/makefile*
+samples/dynamic/*.xbm
+samples/dynamic/*.xpm
+samples/dynamic/*.txt
+samples/dynamic/*.ico
+samples/dynamic/*.bmp
+samples/dynamic/*.rc
+samples/dynamic/*.wav
+
+samples/wxsocket/*.cpp
+samples/wxsocket/*.h
+samples/wxsocket/*.def
+samples/wxsocket/makefile*
+samples/wxsocket/*.xbm
+samples/wxsocket/*.xpm
+samples/wxsocket/*.ico
+samples/wxsocket/*.rc
+
+samples/help/*.cpp
+samples/help/*.h
+samples/help/*.def
+samples/help/makefile*
+samples/help/*.xbm
+samples/help/*.xpm
+samples/help/*.ico
+samples/help/*.rc
+samples/help/doc/*.html
+samples/help/doc/*.htm
+samples/help/doc/*.class
+samples/help/doc/*.db
+samples/help/doc/*.tex
+samples/help/doc/*.gif
+samples/help/doc/*.map
+
+samples/bombs/*.cpp
+samples/bombs/*.h
+samples/bombs/*.def
+samples/bombs/makefile*
+samples/bombs/*.xbm
+samples/bombs/*.xpm
+samples/bombs/*.txt
+samples/bombs/*.ico
+samples/bombs/*.bmp
+samples/bombs/*.rc
+
+samples/ipc/*.cpp
+samples/ipc/*.h
+samples/ipc/*.def
+samples/ipc/makefile*
+samples/ipc/*.xbm
+samples/ipc/*.xpm
+samples/ipc/*.ico
+samples/ipc/*.rc
+
+samples/typetest/*.cpp
+samples/typetest/*.h
+samples/typetest/*.def
+samples/typetest/*.rc
+samples/typetest/*.txt
+samples/typetest/makefile*
+samples/typetest/*.xbm
+samples/typetest/*.xpm
+samples/typetest/*.ico
+
+samples/sashtest/*.cpp
+samples/sashtest/*.h
+samples/sashtest/*.def
+samples/sashtest/*.rc
+samples/sashtest/*.txt
+samples/sashtest/makefile*
+samples/sashtest/*.xbm
+samples/sashtest/*.xpm
+samples/sashtest/*.ico
+
+samples/resource/*.cpp
+samples/resource/*.h
+samples/resource/*.def
+samples/resource/*.rc
+samples/resource/*.txt
+samples/resource/*.wxr
+samples/resource/makefile*
+samples/resource/*.xbm
+samples/resource/*.xpm
+samples/resource/*.ico
+
+samples/animate/*.cpp
+samples/animate/*.h
+samples/animate/*.def
+samples/animate/makefile*
+samples/animate/*.xbm
+samples/animate/*.xpm
+samples/animate/*.ico
+samples/animate/*.rc
+
+samples/mdi/*.cpp
+samples/mdi/*.h
+samples/mdi/*.def
+samples/mdi/makefile*
+samples/mdi/*.xbm
+samples/mdi/*.xpm
+samples/mdi/*.ico
+samples/mdi/*.rc
+samples/mdi/bitmaps/*.bmp
+samples/mdi/bitmaps/*.ico
+samples/mdi/bitmaps/*.xpm
+samples/mdi/bitmaps/*.xbm
+
+samples/minimal/*.cpp
+samples/minimal/*.h
+samples/minimal/*.def
+samples/minimal/makefile*
+samples/minimal/*.xbm
+samples/minimal/*.xpm
+samples/minimal/*.ico
+samples/minimal/*.rc
+
+samples/controls/*.cpp
+samples/controls/*.h
+samples/controls/*.def
+samples/controls/makefile*
+samples/controls/*.xbm
+samples/controls/*.xpm
+samples/controls/*.ico
+samples/controls/*.bmp
+samples/controls/*.rc
+samples/controls/icons/*
+
+samples/fractal/*.cpp
+samples/fractal/*.h
+samples/fractal/*.def
+samples/fractal/makefile*
+samples/fractal/*.xbm
+samples/fractal/*.xpm
+samples/fractal/*.ico
+samples/fractal/*.rc
+
+samples/layout/*.cpp
+samples/layout/*.h
+samples/layout/*.def
+samples/layout/makefile*
+samples/layout/*.xbm
+samples/layout/*.xpm
+samples/layout/*.ico
+samples/layout/*.rc
+samples/layout/*.bmp
+
+samples/printing/*.cpp
+samples/printing/*.h
+samples/printing/*.def
+samples/printing/makefile*
+samples/printing/*.xbm
+samples/printing/*.xpm
+samples/printing/*.txt
+samples/printing/*.ico
+samples/printing/*.bmp
+samples/printing/*.rc
+samples/printing/*.afm
+
+samples/toolbar/*.cpp
+samples/toolbar/*.h
+samples/toolbar/*.def
+samples/toolbar/makefile*
+samples/toolbar/*.txt
+samples/toolbar/*.xbm
+samples/toolbar/*.xpm
+samples/toolbar/bitmaps/*.xbm
+samples/toolbar/bitmaps/*.xpm
+samples/toolbar/*.ico
+samples/toolbar/*.bmp
+samples/toolbar/*.rc
+samples/toolbar/bitmaps/*.bmp
+
+samples/docview/*.h
+samples/docview/*.cpp
+samples/docview/*.def
+samples/docview/*.rc
+samples/docview/makefile*
+samples/docview/*.xbm
+samples/docview/*.xpm
+samples/docview/*.txt
+samples/docview/*.ico
+samples/docview/*.bmp
+
+samples/memcheck/*.h
+samples/memcheck/*.cpp
+samples/memcheck/*.def
+samples/memcheck/*.rc
+samples/memcheck/makefile*
+samples/memcheck/*.xbm
+samples/memcheck/*.xpm
+samples/memcheck/*.txt
+samples/memcheck/*.ico
+samples/memcheck/*.bmp
+
+samples/odbc/*.h
+samples/odbc/*.cpp
+samples/odbc/*.def
+samples/odbc/*.rc
+samples/odbc/makefile*
+samples/odbc/*.inf
+samples/odbc/*.xbm
+samples/odbc/*.xpm
+samples/odbc/*.ico
+samples/odbc/*.bmp
+samples/odbc/*.dbf
+samples/odbc/*.cdx
+
+samples/dialogs/*.h
+samples/dialogs/*.cpp
+samples/dialogs/*.def
+samples/dialogs/*.rc
+samples/dialogs/makefile*
+samples/dialogs/*.xbm
+samples/dialogs/*.xpm
+samples/dialogs/*.txt
+samples/dialogs/*.bmp
+samples/dialogs/*.ico
+
+samples/wxpoem/*.cpp
+samples/wxpoem/*.h
+samples/wxpoem/*.def
+samples/wxpoem/*.rc
+samples/wxpoem/*.inf
+samples/wxpoem/*.txt
+samples/wxpoem/makefile*
+samples/wxpoem/*.xbm
+samples/wxpoem/*.xpm
+samples/wxpoem/*.ico
+samples/wxpoem/*.bmp
+samples/wxpoem/*.dat
+
+samples/pressup/*.cpp
+samples/pressup/*.c
+samples/pressup/*.h
+samples/pressup/*.def
+samples/pressup/*.rc
+samples/pressup/*.inf
+samples/pressup/*.txt
+samples/pressup/makefile*
+samples/pressup/*.xbm
+samples/pressup/*.xpm
+samples/pressup/*.ico
+samples/pressup/*.bmp
+
+samples/validate/*.cpp
+samples/validate/*.h
+samples/validate/*.def
+samples/validate/*.rc
+samples/validate/*.inf
+samples/validate/*.txt
+samples/validate/makefile*
+samples/validate/*.xbm
+samples/validate/*.xpm
+samples/validate/*.ico
+samples/validate/*.bmp
+
+samples/events/*.cpp
+samples/events/*.h
+samples/events/*.def
+samples/events/*.rc
+samples/events/*.inf
+samples/events/*.txt
+samples/events/makefile*
+samples/events/*.xbm
+samples/events/*.xpm
+samples/events/*.ico
+samples/events/*.bmp
+
+samples/treectrl/*.cpp
+samples/treectrl/*.h
+samples/treectrl/*.def
+samples/treectrl/*.rc
+samples/treectrl/*.txt
+samples/treectrl/makefile*
+samples/treectrl/*.xbm
+samples/treectrl/*.xpm
+samples/treectrl/bitmaps/*.xbm
+samples/treectrl/bitmaps/*.xpm
+samples/treectrl/*.ico
+samples/treectrl/*.bmp
+samples/treectrl/bitmaps/*.bmp
+samples/treectrl/bitmaps/*.ico
+
+samples/listctrl/*.cpp
+samples/listctrl/*.h
+samples/listctrl/*.def
+samples/listctrl/*.rc
+samples/listctrl/*.txt
+samples/listctrl/makefile*
+samples/listctrl/*.xbm
+samples/listctrl/*.xpm
+samples/listctrl/bitmaps/*.xbm
+samples/listctrl/bitmaps/*.xpm
+samples/listctrl/*.ico
+samples/listctrl/*.bmp
+samples/listctrl/bitmaps/*.bmp
+samples/listctrl/bitmaps/*.ico
+
+samples/splitter/*.cpp
+samples/splitter/*.h
+samples/splitter/*.def
+samples/splitter/*.rc
+samples/splitter/*.txt
+samples/splitter/makefile*
+samples/splitter/*.xbm
+samples/splitter/*.xpm
+samples/splitter/*.ico
+samples/splitter/*.bmp
+
+samples/grid/*.cpp
+samples/grid/*.h
+samples/grid/*.def
+samples/grid/*.rc
+samples/grid/*.txt
+samples/grid/makefile*
+samples/grid/*.xbm
+samples/grid/*.xpm
+samples/grid/*.ico
+samples/grid/*.bmp
+
+samples/internat/*.cpp
+samples/internat/*.h
+samples/internat/*.def
+samples/internat/*.rc
+samples/internat/*.txt
+samples/internat/makefile*
+samples/internat/*.xbm
+samples/internat/*.xpm
+samples/internat/*.po
+samples/internat/*.ico
+samples/internat/*.bmp
+samples/internat/*.mo
+
+samples/checklst/*.cpp
+samples/checklst/*.h
+samples/checklst/*.def
+samples/checklst/*.rc
+samples/checklst/*.txt
+samples/checklst/makefile*
+samples/checklst/*.xbm
+samples/checklst/*.xpm
+samples/checklst/*.ico
+samples/checklst/*.bmp
+
+samples/dnd/*.cpp
+samples/dnd/*.h
+samples/dnd/makefile*
+samples/dnd/*.rc
+samples/dnd/*.def
+samples/dnd/*.bmp
+samples/dnd/*.xbm
+samples/dnd/*.xpm
+samples/dnd/*.ico
+samples/dnd/*.txt
+
+samples/tab/*.cpp
+samples/tab/*.h
+samples/tab/makefile*
+samples/tab/*.rc
+samples/tab/*.def
+samples/tab/*.bmp
+samples/tab/*.xbm
+samples/tab/*.xpm
+samples/tab/*.ico
+samples/tab/*.txt
+
+samples/notebook/*.cpp
+samples/notebook/*.h
+samples/notebook/makefile*
+samples/notebook/*.rc
+samples/notebook/*.def
+samples/notebook/*.bmp
+samples/notebook/*.xbm
+samples/notebook/*.xpm
+samples/notebook/*.ico
+samples/notebook/*.txt
+
+samples/png/*.cpp
+samples/png/*.h
+samples/png/makefile*
+samples/png/*.rc
+samples/png/*.def
+samples/png/*.bmp
+samples/png/*.xpm
+samples/png/*.xbm
+samples/png/*.ico
+samples/png/*.txt
+samples/png/*.png
+
+samples/image/*.cpp
+samples/image/*.h
+samples/image/makefile*
+samples/image/*.rc
+samples/image/*.def
+samples/image/*.bmp
+samples/image/*.xpm
+samples/image/*.xbm
+samples/image/*.png
+samples/image/*.ico
+samples/image/*.txt
+
+samples/thread/*.cpp
+samples/thread/*.h
+samples/thread/makefile*
+samples/thread/*.rc
+samples/thread/*.def
+samples/thread/*.bmp
+samples/thread/*.xpm
+samples/thread/*.xbm
+samples/thread/*.png
+samples/thread/*.ico
+samples/thread/*.txt
+

distrib/msw/gtk.rsp

@@ -0,0 +1,123 @@
+install-sh
+Makefile
+template.mak
+TODO.txt
+configure.in
+config.guess
+config.sub
+wx-config.in
+mkinstalldirs
+
+docs/gtk/*.html
+docs/gtk/*.txt
+
+include/wx/gtk/*.h
+
+src/Makefile
+src/Makefile.in
+src/*.inc
+
+src/gtk/*.cpp
+src/gtk/*.c
+src/gtk/*.inc
+src/gtk/*.xbm
+
+src/gdk_imlib/*.c
+src/gdk_imlib/*.h
+src/gdk_imlib/AUTHORS
+src/gdk_imlib/AUDIT
+src/gdk_imlib/COPYING.LIB
+src/gdk_imlib/README
+src/gdk_imlib/ChangeLog
+
+src/iodbc/*.c
+src/iodbc/*.ci
+src/iodbc/*.h
+src/iodbc/IAFA-PACKAGE
+src/iodbc/README
+src/iodbc/*.exp
+src/iodbc/*.mk
+src/iodbc/autoconfig
+src/iodbc/build
+src/iodbc/Changes.log
+src/iodbc/postgres/*.h
+
+setup/*.in
+setup/*.hin
+
+setup/general/createall
+setup/general/jointar
+setup/general/makeapp
+setup/general/makedirs
+setup/general/makedoc
+setup/general/mygrep
+setup/general/needed
+
+setup/rules/bin
+setup/rules/bin2
+setup/rules/doc
+setup/rules/gbin
+setup/rules/gbin2
+setup/rules/glib
+setup/rules/glibbin
+setup/rules/glibgbin
+setup/rules/gslib
+setup/rules/lib
+setup/rules/libbin
+setup/rules/libgbin
+
+setup/rules/generic/bin1
+setup/rules/generic/bin1gen
+setup/rules/generic/bin2
+setup/rules/generic/bin2gen
+setup/rules/generic/depend
+setup/rules/generic/globals
+setup/rules/generic/lib
+setup/rules/generic/needed
+setup/rules/generic/obj
+setup/rules/generic/slib
+setup/rules/generic/sobj
+
+setup/shared/sharedAIX
+setup/shared/sharedBsd
+setup/shared/sharedDgux
+setup/shared/sharedHpux
+setup/shared/sharedIrix
+setup/shared/sharedLinux
+setup/shared/sharedOSF
+setup/shared/sharedSolaris2
+setup/shared/sharedSunos4
+setup/shared/sharedSysV
+
+misc/afm/*.afm
+misc/gs_afm/*.afm
+misc/imlib/imrc
+misc/imlib/*.pal
+
+user/Makefile
+
+user/wxConvert/*.cpp
+user/wxConvert/*.h
+user/wxConvert/Makefile
+user/wxConvert/Makefile.in
+
+user/wxFile/*.cpp
+user/wxFile/*.h
+user/wxFile/Makefile
+user/wxFile/Makefile.in
+user/wxFile/*.xpm
+
+user/wxTest/*.cpp
+user/wxTest/*.h
+user/wxTest/Makefile
+user/wxTest/Makefile.in
+user/wxTest/*.xpm
+user/wxTest/*.png
+
+user/wxLayout/*.cpp
+user/wxLayout/*.h
+user/wxLayout/Makefile
+user/wxLayout/Makefile.in
+user/wxLayout/*.xpm
+user/wxLayout/*.png
+

distrib/msw/motif.rsp

@@ -0,0 +1,96 @@
+install-sh
+Makefile
+template.mak
+configure.in
+config.guess
+config.sub
+wx-config.in
+mkinstalldirs
+src/Makefile
+src/Makefile.in
+src/*.inc
+
+setup/*.in
+setup/*.hin
+
+setup/general/createall
+setup/general/jointar
+setup/general/makeapp
+setup/general/makedirs
+setup/general/makedoc
+setup/general/mygrep
+setup/general/needed
+
+setup/rules/bin
+setup/rules/bin2
+setup/rules/doc
+setup/rules/gbin
+setup/rules/gbin2
+setup/rules/glib
+setup/rules/glibbin
+setup/rules/glibgbin
+setup/rules/gslib
+setup/rules/lib
+setup/rules/libbin
+setup/rules/libgbin
+
+setup/rules/generic/bin1
+setup/rules/generic/bin1gen
+setup/rules/generic/bin2
+setup/rules/generic/bin2gen
+setup/rules/generic/depend
+setup/rules/generic/globals
+setup/rules/generic/lib
+setup/rules/generic/needed
+setup/rules/generic/obj
+setup/rules/generic/slib
+setup/rules/generic/sobj
+
+setup/shared/sharedAIX
+setup/shared/sharedBsd
+setup/shared/sharedDgux
+setup/shared/sharedHpux
+setup/shared/sharedIrix
+setup/shared/sharedLinux
+setup/shared/sharedOSF
+setup/shared/sharedSolaris2
+setup/shared/sharedSunos4
+setup/shared/sharedSysV
+
+misc/afm/*.afm
+
+src/motif/*.cpp
+src/motif/*.c
+src/motif/*.h
+src/motif/makefile*
+src/motif/*.inc
+src/motif/*.xbm
+src/motif/xmcombo/*.c
+src/motif/xmcombo/*.h
+src/motif/xmcombo/*.doc
+src/motif/xmcombo/*.man
+src/motif/xmcombo/*.txt
+src/motif/mdi/COPYRIGHT
+src/motif/mdi/Imakefile
+src/motif/mdi/Readme
+src/motif/mdi/config/C++.rules
+src/motif/mdi/config/MDI.tmpl
+src/motif/mdi/doc/*.html
+src/motif/mdi/doc/pics/*.gif
+src/motif/mdi/lib/*.C
+src/motif/mdi/lib/*.h
+src/motif/mdi/lib/*.xbm
+src/motif/mdi/lib/Imakefile
+src/motif/mdi/test/*.C
+src/motif/mdi/test/Imakefile
+
+src/make.env
+src/makeprog.env
+
+include/wx/motif/*.h
+
+docs/motif/*.*
+
+lib/dummy
+
+

distrib/msw/msw.rsp

@@ -0,0 +1,133 @@
+docs/msw/*.txt
+docs/licence.txt
+
+distrib/msw/*.rsp
+distrib/msw/*.bat
+
+src/makeb32.env
+src/makebcc.env
+src/makemsw.env
+src/makewat.env
+src/makesc.env
+src/makeg95.env
+src/makem95.env
+src/ntwxwin.mak
+src/makefile.bcc
+src/makefile.dos
+src/makefile.nt
+src/*.bat
+
+src/common/dosyacc.c
+src/common/doslex.c
+
+src/msw/*.cpp
+src/msw/*.h
+src/msw/makefile.*
+src/msw/*.lst
+src/msw/*.def
+src/msw/*.inc
+
+src/msw/ctl3d/*.*
+src/msw/ctl3d/msvc/*.*
+src/msw/ctl3d/wat32/*.*
+src/msw/ctl3d/wat386/*.*
+src/msw/ctl3d/borland/*.*
+src/msw/ole/*.cpp
+src/msw/*.prj
+
+include/wx/msw/*.h
+include/wx/msw/*.rc
+include/wx/msw/ctl3d/*.h
+include/wx/msw/gnuwin32/*.h
+include/wx/msw/ole/*.h
+include/wx/msw/*.cur
+include/wx/msw/*.ico
+include/wx/msw/*.bmp
+
+lib/dummy
+
+samples/ownerdrw/*.cpp
+samples/ownerdrw/*.h
+samples/ownerdrw/makefile.*
+samples/ownerdrw/*.rc
+samples/ownerdrw/*.def
+samples/ownerdrw/*.bmp
+samples/ownerdrw/*.ico
+samples/ownerdrw/*.txt
+
+samples/taskbar/*.cpp
+samples/taskbar/*.h
+samples/taskbar/makefile.*
+samples/taskbar/*.rc
+samples/taskbar/*.def
+samples/taskbar/*.bmp
+samples/taskbar/*.ico
+samples/taskbar/*.txt
+
+samples/regtest/*.cpp
+samples/regtest/*.h
+samples/regtest/makefile.*
+samples/regtest/*.rc
+samples/regtest/*.def
+samples/regtest/*.bmp
+samples/regtest/*.ico
+samples/regtest/*.txt
+
+samples/nativdlg/*.cpp
+samples/nativdlg/*.h
+samples/nativdlg/*.def
+samples/nativdlg/*.rc
+samples/nativdlg/*.txt
+samples/nativdlg/makefile.*
+samples/nativdlg/*.xbm
+samples/nativdlg/*.ico
+samples/nativdlg/*.bmp
+
+samples/mfc/*.h
+samples/mfc/*.cpp
+samples/mfc/*.def
+samples/mfc/*.rc
+samples/mfc/makefile.*
+samples/mfc/*.txt
+samples/mfc/*.bmp
+samples/mfc/*.ico
+
+samples/joytest/*.h
+samples/joytest/*.cpp
+samples/joytest/*.def
+samples/joytest/*.rc
+samples/joytest/makefile.*
+samples/joytest/*.txt
+samples/joytest/*.bmp
+samples/joytest/*.wav
+samples/joytest/*.ico
+
+utils/nplugin/make*.*
+utils/nplugin/src/*.cpp
+utils/nplugin/src/*.h
+utils/nplugin/src/*.rc
+utils/nplugin/src/*.def
+utils/nplugin/src/makefile.*
+utils/nplugin/src/*.txt
+utils/nplugin/samples/simple/*.cpp
+utils/nplugin/samples/simple/*.h
+utils/nplugin/samples/simple/*.rc
+utils/nplugin/samples/simple/*.def
+utils/nplugin/samples/simple/makefile.*
+utils/nplugin/samples/simple/*.txt
+utils/nplugin/samples/gui/*.cpp
+utils/nplugin/samples/gui/*.h
+utils/nplugin/samples/gui/*.rc
+utils/nplugin/samples/gui/*.def
+utils/nplugin/samples/gui/makefile.*
+utils/nplugin/samples/gui/*.txt
+utils/nplugin/docs/*.tex
+utils/nplugin/docs/*.txt
+utils/nplugin/docs/*.hpj
+utils/nplugin/docs/*.eps
+utils/nplugin/docs/*.ps
+utils/nplugin/docs/*.ini
+utils/nplugin/docs/*.cnt
+utils/nplugin/docs/*.hlp
+utils/nplugin/lib/dummy
+

distrib/msw/stubs.rsp

@@ -0,0 +1,14 @@
+src/stubs/*.cpp
+src/stubs/*.h
+src/stubs/makefile*
+src/stubs/*.inc
+
+src/make.env
+src/makeprog.env
+
+include/wx/stubs/*.h
+include/wx/stubs/*.rc
+
+lib/dummy
+
+

distrib/msw/tardist.bat

@@ -0,0 +1,117 @@
+@echo off
+rem Tar up an external distribution of wxWindows 2.0: but
+rem putting in separate ASCII and binary files
+rem This seems to be the one that works, using
+rem separate tar programs for conversion/non-conversion
+rem of ASCII/binary files.
+
+if "%1" == "" goto usage
+if "%2" == "" goto usage
+echo About to archive an external wxWindows 2.0 distribution:
+echo   From   %1
+echo   To     %2\wx200_1.tgz, %2\wx200_2.tgz, %2\wx200hlp.tgz, %2\wx200ps.tgz, %2\wx200htm.tgz
+echo CTRL-C if this is not correct.
+inkey /W4 `Press any key to continue...` %%input
+
+erase %2\*.tgz
+cd %1
+
+rem First, expand the wildcards in the rsp files
+
+rem Create empty list file
+erase %1\distrib\*.lis
+c:\bin\touch %1\distrib\wx200asc.lis
+c:\bin\touch %1\distrib\wx200bin.lis
+c:\bin\touch %1\distrib\wx200hlp.lis
+c:\bin\touch %1\distrib\wx200ps.lis
+c:\bin\touch %1\distrib\wx200xlp.lis
+
+rem Create a .rsp file with backslashes instead
+rem of forward slashes
+rem No need if using ls2 (from UNIX95 distribution)
+rem sed -e "s/\//\\/g" %1\distrib\wx_asc.rsp > %1\distrib\wx_asc.rs2
+
+call %1\distrib\expdwild.bat %1\distrib\wx_asc.rsp %1\distrib\wx200asc.lis
+call %1\distrib\expdwild.bat %1\distrib\util_asc.rsp %1\distrib\wx200asc.lis
+call %1\distrib\expdwild.bat %1\distrib\smpl_asc.rsp %1\distrib\wx200asc.lis
+rem call %1\distrib\expdwild.bat %1\distrib\wxim1asc.rsp %1\distrib\wx200asc.lis
+rem call %1\distrib\expdwild.bat %1\distrib\wxim2asc.rsp %1\distrib\wx200asc.lis
+
+call %1\distrib\expdwild.bat %1\distrib\wx_bin.rsp %1\distrib\wx200bin.lis
+call %1\distrib\expdwild.bat %1\distrib\util_bin.rsp %1\distrib\wx200bin.lis
+call %1\distrib\expdwild.bat %1\distrib\smpl_bin.rsp %1\distrib\wx200bin.lis
+rem call %1\distrib\expdwild.bat %1\distrib\wxim1bin.rsp %1\distrib\wx200bin.lis
+
+rem Docs
+call %1\distrib\expdwild.bat %1\distrib\wx_hlp.rsp %1\distrib\wx200hlp.lis
+call %1\distrib\expdwild.bat %1\distrib\wx_ps.rsp %1\distrib\wx200ps.lis
+call %1\distrib\expdwild.bat %1\distrib\wx_html.rsp %1\distrib\wx200htm.lis
+call %1\distrib\expdwild.bat %1\distrib\wx_pdf.rsp %1\distrib\wx200pdf.lis
+
+rem Do some further massaging of the .lis files
+sed -e "s/\\/\//g" %1\distrib\wx200asc.lis > c:\temp\temp.tmp
+sed -e "s/D:\/wx\///g" c:\temp\temp.tmp > %1\distrib\wx200asc.lis
+
+sed -e "s/\\/\//g" %1\distrib\wx200bin.lis > c:\temp\temp.tmp
+sed -e "s/D:\/wx\///g" c:\temp\temp.tmp > %1\distrib\wx200bin.lis
+
+sed -e "s/\\/\//g" %1\distrib\wx200hlp.lis > c:\temp\temp.tmp
+sed -e "s/D:\/wx\///g" c:\temp\temp.tmp > %1\distrib\wx200hlp.lis
+
+sed -e "s/\\/\//g" %1\distrib\wx200ps.lis > c:\temp\temp.tmp
+sed -e "s/D:\/wx\///g" c:\temp\temp.tmp > %1\distrib\wx200ps.lis
+
+sed -e "s/\\/\//g" %1\distrib\wx200htm.lis > c:\temp\temp.tmp
+sed -e "s/D:\/wx\///g" c:\temp\temp.tmp > %1\distrib\wx200htm.lis
+
+sed -e "s/\\/\//g" %1\distrib\wx200pdf.lis > c:\temp\temp.tmp
+sed -e "s/D:\/wx\///g" c:\temp\temp.tmp > %1\distrib\wx200pdf.lis
+
+rem 'tar' converts linefeeds.
+tar -c -T %1\distrib\wx200asc.lis -f %2\wx200.tar
+rem pause Press a key to continue.
+
+rem This converts to lower case
+ren %2\wx200.tar %2\wx200_1.tar
+gzip32 %2\wx200_1.tar
+ren %2\wx200_1.tar.gz %2\wx200_1.tgz
+
+rem No linefeed conversion wanted
+rem Note: GNU tar seems to crash with a full destination path, so
+rem pander to it.
+targnu -c -T %1\distrib\wx200bin.lis -f wx200_2.tar
+move wx200_2.tar %2
+gzip32 %2\wx200_2.tar
+ren %2\wx200_2.tar.gz %2\wx200_2.tgz
+
+targnu -c -T %1\distrib\wx200hlp.lis -f wx200_hlp.tar
+move wx200_hlp.tar %2
+gzip32 %2\wx200_hlp.tar
+ren %2\wx200_hlp.tar.gz %2\wx200hlp.tgz
+
+tar -c -T %1\distrib\wx200ps.lis -f %2\wx200ps.tar
+gzip32 %2\wx200ps.tar
+ren %2\wx200ps.tar.gz %2\wx200ps.tgz
+
+targnu -c -T %1\distrib\wx200htm.lis -f wx200htm.tar
+move wx200htm.tar %2
+gzip32 %2\wx200htm.tar
+ren %2\wx200htm.tar.gz %2\wx200htm.tgz
+
+targnu -c -T %1\distrib\wx200pdf.lis -f wx200pdf.tar
+move wx200pdf.tar %2
+gzip32 %2\wx200pdf.tar
+ren %2\wx200pdf.tar.gz %2\wx200pdf.tgz
+
+cd %2
+echo wxWindows archived.
+goto end
+
+:usage
+echo Tar/gzip wxWindows distribution under DOS, making an ASCII and binary file
+echo Usage: tardist source destination
+echo e.g. tardist d:\wx d:\wx\deliver
+
+:end
+
+

distrib/msw/wx_hlp.rsp

@@ -0,0 +1,2 @@
+docs/winhelp/*.hlp
+docs/winhelp/*.cnt

distrib/msw/wx_html.rsp

@@ -0,0 +1,38 @@
+docs/html/*.htm
+docs/html/*.gif
+
+docs/html/wx/*.htm
+docs/html/wx/*.gif
+docs/html/porting/*.htm
+docs/html/porting/*.gif
+docs/html/faq/*.htm
+docs/html/faq/*.gif
+docs/html/techref/*.htm
+docs/html/techref/*.gif
+docs/html/prologio/*.htm
+docs/html/prologio/*.gif
+docs/html/dialoged/*.htm
+docs/html/dialoged/*.gif
+docs/html/wxbuild/*.htm
+docs/html/wxbuild/*.gif
+docs/html/wxtab/*.htm
+docs/html/wxtab/*.gif
+docs/html/wxchart/*.htm
+docs/html/wxchart/*.gif
+docs/html/wxtree/*.htm
+docs/html/wxtree/*.gif
+docs/html/wxgraph/*.htm
+docs/html/wxgraph/*.gif
+docs/html/wxgrid/*.htm
+docs/html/wxgrid/*.gif
+docs/html/wxhelp/*.htm
+docs/html/wxhelp/*.gif
+docs/html/wxhelp2/*.htm
+docs/html/wxhelp2/*.gif
+docs/html/wxprop/*.htm
+docs/html/wxprop/*.gif
+docs/html/winstall/*.htm
+docs/html/winstall/*.gif
+docs/html/tex2rtf/*.htm
+docs/html/tex2rtf/*.gif
+

distrib/msw/wx_pdf.rsp

@@ -0,0 +1 @@
+docs/pdf/*.pdf

distrib/msw/zipdist.bat

@@ -0,0 +1,40 @@
+@echo off
+rem Zip up an external, generic + Windows distribution of wxWindows 2.0
+set src=d:\wx2\wxWindows
+set dest=%src\deliver
+if "%src" == "" goto usage
+if "%dest" == "" goto usage
+echo About to archive an external wxWindows distribution:
+echo   From   %src
+echo   To     %dest
+echo CTRL-C if this is not correct.
+pause
+
+erase %dest\wx200*.zip
+
+cd %src
+echo Zipping...
+zip32 -@ %dest\wx200gen.zip < %src\distrib\msw\generic.rsp
+zip32 -@ %dest\wx200msw.zip < %src\distrib\msw\msw.rsp
+zip32 -@ %dest\wx200gtk.zip < %src\distrib\msw\gtk.rsp
+zip32 -@ %dest\wx200stubs.zip < %src\distrib\msw\stubs.rsp
+zip32 -@ %dest\wx200mot.zip < %src\distrib\msw\motif.rsp
+zip32 -@ %dest\wx200doc.zip < %src\distrib\msw\docsrc.rsp
+
+zip32 -@ %dest\wx200hlp.zip < %src\distrib\msw\wx_hlp.rsp
+zip32 -@ %dest\wx200htm.zip < %src\distrib\msw\wx_html.rsp
+zip32 -@ %dest\wx200pdf.zip < %src\distrib\msw\wx_pdf.rsp
+
+zip32 -@ %dest\ogl3.zip < %src\utils\ogl\distrib\ogl.rsp
+
+cd %dest
+
+echo wxWindows archived.
+goto end
+
+:usage
+echo DOS wxWindows distribution.
+echo Usage: zipdist source destination
+echo e.g. zipdist d:\wx2\wxWindows d:\wx2\wxWindows\deliver
+
+:end

docs/changes.txt

@@ -0,0 +1,232 @@
+Generic wxWindows 2.0 Change Log
+--------------------------------
+
+Note: for platform-specific changes, see wx/docs/XXX/changes.txt
+where XXX is one of msw, motif, xt, gtk, mac.
+
+Alpha 11, July 3rd 1998
+-----------------------
+
+- Major work on Dialog Editor (still plenty to go).
+- Expanded documentation a bit more.
+
+Alpha 9, April 27th 1998
+------------------------
+
+- Corrected some bugs, such as the wxModule compilation problem.
+- Added Gnu-Win32 b19/Mingw32 support by changing resource
+  compilation and pragmas.
+- Changed SIZEOF to WXSIZEOF.
+
+Alpha 8, April 17th 1998
+------------------------
+
+- Added src/other/png, src/other/zlib directories.
+- Added samples/png.
+- IMPORTANT: Changed 'no id' number from 0 to -1, in wxEVT_ macros.
+  Porters, please check particularly your wxTreeCtrl and wxListCtrl
+  header files.
+- Added modules.h/cpp, config.cpp, fileconf.cpp, textfile.cpp/h.
+
+Alpha 7, March 30th 1998
+------------------------
+
+- Added tab classes, tab sample.
+- Revised memory.cpp, memory.h slightly; memory.h now #defines
+  new to WXDEBUG_NEW in DEBUG mode. Windows implementation app.cpp
+  now checks for leaks on exit. Added memcheck sample.
+  See src/msw/issues.txt for more details.
+- resource.h, resource.cpp changed to make wxDefaultResourceTable
+  a pointer. Now initialize resource system with
+  wxInitializeResourceSystem and wxCleanUpResourceSystem, to
+  allow better control of memory.
+- wxString now derives from wxObject, to enable memory leak
+  checking.
+- Added some #include fixes in various files, plus changed
+  float to long in wxToolBar files.
+
+Alpha 6, March 10th 1998
+------------------------
+
+- Added Vadim's dynarray.h, dynarray.cpp.
+- Added Vadim's menuitem.cpp.
+- Added Windows-specific wxCheckListBox,
+  owner-draw wxListBox, and drag-and-drop
+  (see docs/msw/changes.txt).
+
+Alpha 5, 14th February 1998
+--------------------------
+
+- GENERIC AND MSW-SPECIFIC CODE NOW TREATED AS TWO SEPARATE
+  DISTRIBUTIONS. This change log will therefore now refer to
+  the generic code only. See docs/msw/changes.txt for Windows-specific
+  changes.
+- Readmes, change logs and installation files now go in
+  platform-specific directories under docs, e.g. docs/msw,
+  docs/gtk.
+- Added DECLARE_APP and IMPLEMENT_APP macros so wxApp object gets
+  created dynamically, not as a global object.
+- Put wxColour into wx/msw/colour.h, src/msw/colour.cpp.
+- Changed names of some include/wx/generic headers to be
+  consistent and to conform to gcc pragma conventions. Also
+  changed choicesg.cpp to choicdgg.cpp.
+- Added gcc pragmas.
+- Added gtk inclusion in include/wx headers.
+- Added consistent file headings to source and headers.
+- Removed lang.cpp, lang.h and references to wxSTR_... variables;
+  added a few references to wxTransString.
+- Added operator to wxTransString that converts automatically
+  to wxString, so we can say e.g. wxMessageBox(wxTransString("Hello"), ...).
+- samples/internat now works (minimally).
+- Added wxMouseEvent::GetPosition and
+  wxMouseEvent::GetLogicalPosition, both returning wxPoints.
+- Made wxSize and wxRect contain longs not ints.
+- Cured some lemory leaks (thanks Vadim).
+- Tidied up OnIdle and introduced RequestMore/MoreRequested so
+  will only keep processing OnIdle if it returns TRUE from
+  MoreRequested.
+
+Alpha 4, 31st January 1998
+--------------------------
+
+- Changed wxDC functions to take longs instead of floats. GetSize now takes
+  integer pointers, plus a version that returns a wxSize.
+- const keyword added to various wxDC functions.
+- Under Windows, wxDC no longer has any knowledge of whether
+  an associated window is scrolled or not. Instead, the device
+  origin is set by wxScrolledWindow in wxScrolledWindow::PrepareDC.
+- wxScrolledWindow applications can optionally override the virtual OnDraw
+  function instead of using the OnPaint event handler. The wxDC passed to
+  OnDraw will be translated by PrepareDC to reflect scrolling.
+  When drawing outside of OnDraw, must call PrepareDC explicitly.
+- wxToolBarBase/wxToolBarSimple similarly changed to allow for
+  scrolling toolbars.
+- Integrated wxPostScriptDC patches for 1.xx by Chris Breeze,
+  to help printing with multiple pages.
+- IPC classes given base classes (wxConnectionBase etc.) which
+  define the API used by different implementations. DDE
+  implementation updated to use these base classes.
+- wxHelpInstance now separated into wxHelpControllerBase (base
+  for all implementations), wxWinHelpController (uses standard
+  WinHelp), wxXLPHelPController (talks to wxHelp by DDE or
+  TCP/IP). There will be others eventually, such as
+  wxHTMLHelpController for Microsoft (and Netscape?) HTML Help.
+- Added Vadim Zeitlin's wxString class plus
+  internationalization code (gettext simulation, wxLocale, etc.).
+  New files from Vadim:
+  include\wx\string.h
+  include\wx\debug.h
+  include\wx\file.h
+  include\wx\log.h
+  include\wx\intl.h
+  src\common\string.cpp
+  src\common\log.cpp
+  src\common\intl.cpp
+  src\common\file.cpp
+  No longer use GNU wxString files.
+- Split off file-related functions into include\wx\filefn.h and
+  src\common\filefn.cpp.
+- Borland C++ support (WIN32) for main library and
+  samples, using makefile.b32 files.
+- Preparation done for allowing BC++ to compile wxWin as a DLL,
+  including changes to defs.h.
+- wxIntPoint removed, wxPoint is now int, and wxRealPoint
+  introduced.
+- Added wxShowEvent (generated when window is being shown or
+  hidden).
+- Got minimal, docview, mdi samples working for 16-bit VC++ and
+  cured 16-bit problem with wxTextCtrl (removed global memory
+  trick).
+- Updated GnuWin32 makefiles, checked minimal, mdi, docview samples.
+
+Alpha 3, September 1997
+-----------------------
+
+- wxListCtrl, wxTreeCtrl, wxImageList classes done.
+- Instigated new file hierarchy, split files and classes up more logically.
+- PrologIO and some other utils now put into core library.
+- Revamped print/preview classes, added wxPageSetupDialog.
+- Started documentation.
+
+Alpha 2, 30th April 1997
+------------------------
+
+- EVT_... macros now have at least one argument, for conformance
+  with MetroWerks compiler.
+- Added ids to .wxr file format.
+- Got Dialog Editor compiled and running again but need
+  to extend functionality to be in line with new controls.
+  Added dialoged\test app to allow dynamic loading of .wxr files
+  for testing purposes.
+- Rewrote wxBitmap to allow installable file type
+  handlers.
+- Rewrote wxBitmapButton, wxStaticBitmap to not use Fafa.
+- Wrote most of wxTreeCtrl and sample (need wxImageList to implement it
+  fully).
+- Added back wxRadioBox.
+- Tidied up wx_main.cpp, wxApp class, putting PenWin code in
+  a separate file.
+
+Alpha 1, 5th April 1997
+-----------------------
+
+At this point, the following has been achieved:
+
+- A lot, but not all, of the code has been revamped for better
+  naming conventions, protection of data members, and use of
+  wxString instead of char *.
+- Obsolete functionality deleted (e.g. default wxPanel layout,
+  old system event system) and code size reduced.
+- Class hierarchy changed (see design doc) - base classes such
+  as wxbWindow now removed.
+- No longer includes windows.h in wxWin headers, by using stand-in
+  Windows types where needed e.g. WXHWND.
+- PrologIO revised.
+- wxScrolledWindow, wxStatusBar and new MDI classes added.
+  MDI is now achived using separate classes, not window styles.
+- wxSystemSettings added, and made use of to reflect standard
+  Windows settings.
+- SetButtonFont/SetLabelFont replaced by SetFont; font and colour
+  settings mucho rationalised.
+- All windows are now subclassed with the same window proc to make
+  event handling far more consistent. Old internal wxWnd and derived
+  classes removed.
+- API for controls revised, in particular addition of
+  wxValidator parameters and removal of labels for some controls.
+- 1 validator written: see examples/validate.
+- Event table system introduced (see most samples and
+  wx_event.cpp/ProcessEvent, wx_event.h). wxEvtHandler
+  made more flexible, with Push/PopEventHandler allowing a chain
+  of event handlers.
+- wxRadioBox removed - will be added back soon.
+- Toolbar class hierarchy revised:
+  wxToolBarBase
+  wxToolBarSimple (= old wxToolBar)
+  wxToolBar95 (= old wxButtonBar under Win95
+  wxToolBarMSW (= old wxButtonBar under WIN16/WIN32)
+- Constraint system debugged somewhat (sizers now work properly).
+- wxFileDialog, wxDirDialog added; other common dialogs now
+  have class equivalents. Generic colour and font dialogs
+  rewritten to not need obsolete panel layout.
+- .wxr resource system partially reinstated, though needs
+  an integer ID for controls. Hopefully the resource system
+  will be replaced by something better and more efficient
+  in the future.
+- Device contexts no longer stored with window and accessed
+  with GetDC - use wxClientDC, wxPaintDC, wxWindowDC stack
+  variables instead.
+- wxSlider uses trackbar class under Win95, and wxSL_LABELS flag
+  determines whether labels are shown. Other Win95-specific flags
+  introduced, e.g. for showing ticks.
+- Styles introduced for dealing with 3D effects per window, for
+  any window: all Win95 3D effects supported, plus transparent windows.
+- Major change to allow 3D effect support without CTL3D, under
+  Win95.
+- Bitmap versions of button and checkbox separated out into new
+  classes, but unimplemented as yet because I intend to remove
+  the need for Fafa - it apparently causes GPFs in Win95 OSR 2.
+- utils/wxprop classes working (except maybe wxPropertyFormView)
+  in preparation for use in Dialog Editor.
+- GNU-WIN32 compilation verified (a month or so ago).
+
+

docs/gtk/COPYING.LIB

@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

docs/gtk/install.txt

@@ -0,0 +1,429 @@
+* The most simple case
+-----------------------
+
+If you compile wxWindows on Unix for the first time and don't like
+to read install instructions just do (in the base dir):
+
+./configure --without-threads
+make
+
+and drink 10 coffees. Then you may log in as root and type
+
+make install
+
+You can leave out the --without-threads option if you have a NEW
+Linux distribution based on glibc (e.g. RedHat 5.1 or Debian 2.0) 
+or any other Unix that comes with Posix threads or SGI threads.
+
+Now create your super-application myfoo.app and compile anywhere with
+
+g++ myfoo.cpp `wx-config --libs` `wx-config --cflags` -o myfoo
+
+* General
+-----------------------
+
+The Unix variants of wxWindows use GNU configure. If you have problems 
+with your make use GNU make instead.
+
+Read my homepage at 
+
+  http://wesley.informatik.uni-freiburg.de/~wxxt
+  
+for newest information.
+
+* GUI libraries
+-----------------------
+
+wxWindows/GTK requires the GTK+ library to be installed on your system.
+It has to be a stable version, preferebly version 1.0.6. When using
+a version previous to 1.0.6 you'll get crashes here and there. This
+is certain to happen with colors in native widgets.
+
+You can get the newest version of the GTK+ from the GTK homepage
+at
+  http://www.gtk.org
+  
+We also mirror GTK+ 1.0.6 at our ftp site. You'll find information
+about downloading at my homepage.
+  
+* Additional libraries
+-----------------------
+
+wxWindows/Gtk requires a thread library and X libraries
+known to work with threads. This is the case on all
+commercial Unix-Variants and all Linux-Versions that
+are based on glibc 2 except RedHat 5.0 which is broken
+in many aspects. As of writing this, these Linux 
+distributions have correct glibc 2 support:
+
+ - RedHat 5.1
+ - Debian 2.0
+ - Stampede
+ 
+The next major version of SuSE will also support glibc 2,
+but version 5.X does not. Also Caldera and Slackware
+don't yet support glibc 2.
+
+On IRIX you can also use SGI threads if Posix-Threads
+are not present. The SGI threads will be detected by
+configure automatically.
+
+You can always disable thread support by running 
+
+./configure "--without-threads"
+make clean
+make
+  
+NB: I included thread support in wxWindows/Gtk, as this 
+problem will disappear in the near future when all major 
+Linux Variants have moved to glibc 2. Also, the Linux
+Base Standard will include glibc 2.
+
+* Create your configuration
+-----------------------------
+
+Usage:
+	./configure options
+
+If you want to use system's C and C++ compiler,
+set environment variables CC and CCC as
+
+	% setenv CC cc
+	% setenv CCC CC
+	% ./configure options
+
+Using the SGI native compilers, it is recommended that you
+also set CFLAGS and CXXFLAGS before running configure. These 
+should be set to :
+
+CFLAGS="-mips3 -n32" 
+CXXFLAGS="-mips3 -n32"
+
+This is essential if you want to use the resultant binaries 
+on any other machine than the one it was compiled on. If you 
+have a 64bit machine (Octane) you should also do this to ensure 
+you don't accidently build the libraries as 64bit (which is 
+untested).
+
+The SGI native compiler support has only been tested on Irix 6.5.
+
+to see all the options please use:
+
+	./configure --help
+
+The basic philosophy is that if you want to use different
+configurations, like a debug and a release version, 
+or use the same source tree on different systems,
+you have only to change the environment variable OSTYPE.
+(Sadly this variable is not set by default on some systems
+in some shells - on SGI's for example). So you will have to 
+set it there. This variable HAS to be set before starting 
+configure, so that it knows which system it tries to 
+configure for.
+
+Configure will complain if the system variable OSTYPE has 
+not been defined. And Make in some circumstances as well...
+
+
+* General options
+-------------------
+
+Normally, you won't have to choose a toolkit, because when
+you download wxGTK, it will default to --with-gtk etc. But
+if you use all of our CVS repository you have to choose a 
+toolkit. You must do this by running configure with either of:
+
+        --with-gtk               Use the GIMP ToolKit (GTK)
+	
+	--with-qt                Use Qt from TrollTec
+	
+	--with-motif             Use either Motif or Lesstif
+	                         Configure will look for both. 
+
+The following options handle the kind of library you want to build.
+
+	--without-threads       Compile without thread support.
+
+	--without-shared        Do not create shared libraries.
+
+	--without-optimise	Do not optimise the code.
+
+	--with-profile          Add profiling info to the object 
+				files. Currently broken, I think.
+				
+	--with-mem_tracing      Add built-in memory tracing. 
+	                        This doesn't work well with gcc.
+				
+	--with-dmalloc          Use the dmalloc memory debugger.
+	                        Read more at www.letters.com/dmalloc/
+				
+	--with-debug_info	Add debug info to object files and
+	                        executables.
+
+	--with-debug_flag	Define __DEBUG__ and __WXDEBUG__ when
+	                        compiling.
+
+* Feature Options
+-------------------
+
+As I don't yet care for binary size and target mainly at
+producing a shared library, wxWindows's configure system auto-
+matically enables all features, as long as they are already
+implemented. It is currently NOT possible to disable these
+options (in contrast to what configure tells you).
+
+* Compiling
+-------------
+
+The following must be done in the base directory (e.g. ~/wxGTK
+or ~/wxWin or whatever)
+
+Now the makefiles are created and you can compile everything 
+by typing:
+
+	make
+
+make yourself some coffee, as it will try to compile ALL the 
+files in this distribution. During compilation, you'll get
+a few warning messages.
+
+if you want to be more selective:
+
+	make src	will build only the base libraries
+	make samples	will build the samples
+	make other	will build everything in other
+	make user	will build everything in user
+
+Then you may install the library and it's header files under
+/usr/local/include/wx and /usr/local/lib respectively. You
+have to log in as root (i.e. run "su" and enter the root
+password) and type
+
+        make install	
+	
+Depending on the configuration of some files, the libraries
+and binaries will be placed in different directories.
+The "global" binaries and libraries will be placed in:
+
+	bin/$(OSTYPE) and
+	lib/$(OSTYPE) respectively
+
+"local" binaries and libraries will be placed in:
+
+	(basedir of that application)/$(OSTYPE).
+
+This is also the place where all the object-files will go.
+
+If you want to conserve disk space by removing unnecessary
+object-files:
+
+	 make clean_obj
+
+will do the work for you.
+
+* Creating a new Project
+--------------------------
+
+There are two ways to create your own project:
+
+1) The first way uses the installed libraries and header files
+automatically using wx-config
+
+g++ myfoo.cpp `wx-config --libs` `wx-config --cflags` -o myfoo
+
+Using this way, a make file for the minimal sample would look
+like this
+
+CC = g++
+
+minimal: minimal.o
+    $(CC) -o minimal minimal.o `wx-config --libs` 
+
+minimal.o: minimal.cpp mondrian.xpm
+    $(CC) `wx-config --cflags` -c minimal.cpp -o minimal.o
+
+clean: 
+	rm -f *.o minimal
+
+This is certain to become the standard way unless we decide
+to sitch to tmake.
+
+2) The other way creates a project within the source code 
+directories of wxWindows: In this case I propose to put 
+all contributed programs in the directory "/user", with a 
+directory of its own.
+
+This directory then should include the following files:
+
+Makefile        (You can copy this one from any application in samples
+                 probably you will not need to edit this one. There is
+                 only one case where you might be interested in changing
+                 this file, but about that see later.)
+Makefile.in	(This is the base application-Makefile template, from
+                 which the actual Makefile for each system is created.
+                 More about this later)
+
+put ALL your source code along with all the other stuff you need for
+your application in this directory (subdirectories are welcome).
+
+
+** Something about Makefiles
+------------------------------
+
+On general principle it should only contain ONE line, which is as follows:
+
+	include ../../setup/general/makeapp
+
+this will include all the necessary definitions for creating the applications
+
+the only case where you might want to add another line is the following:
+this version of configure also supports creation of source archives of the
+application for easy distribution and updates to newer version of wxWindows.
+    For this purpose all files in the application-directory will be put into
+a gziped tar-file in the full notation user/<your application>/*
+if you want to include some other files that you want "more visible", like
+a README.<yourApp> or a shell script for easy 
+compilation/installation/distribution, then you have to add a variable
+
+	DISTRIBUTE_ADDITIONAL=<your files>
+
+to the Makefile.
+So it would look like this:
+
+	DISTRIBUTE_ADDITIONAL=README.TheApp
+	include ../../setup/general/makeapp
+
+As we have already talked about distribution the command to create a 
+distribution is:
+
+	make distrib
+
+NOTE: If you are in the base directory of wxWindows it will create 
+distribution packages for wxWindows as well as for all packages in the
+user directory.
+    So if you want to create only packages for the files in user,
+then go to the directory other and type:
+
+	make distrib
+
+or if you only want one application to be created then
+enter the specific directory and type there:
+make distrib
+
+All the distribution files will be put in the directory
+distrib at the base of the wxWindows-tree (where also configure
+and template.mak can be found).
+
+** Something about Makefile.in
+--------------------------------
+
+As you have already seen with Makefile, configure makes a lot of use
+if the include statement in make to keep the Makefiles as simple as 
+possible.
+
+So basically there are only variables to define and then a include command.
+Exception to this rule is if you have special rules for some stuff...
+These rules should go AFTER the include statement!!!
+
+so the general header looks like this:
+
+	# wxWindows base directory
+	WXBASEDIR=@WXBASEDIR@
+	# set the OS type for compilation
+	OS=@OS@
+	# compile a library only
+	RULE=bin
+
+and the general footer will look like this:
+
+	# include the definitions now
+	include ../../../template.mak
+
+the key variable is RULE, which defines what make should create
+in this directory.
+
+here are some examples:
+
+  RULE	  description              
+  ===========================================================================
+  bin	  creates a local binary (for a global binary prefix bin with g)
+  	  additional variables needed:
+  		BIN_TARGET	this gives the name of your application
+  		BIN_OBJ		this gives the object files needed to
+  				link the application
+  	  optional variables are:
+  		BIN_SRC		this gives the list of c/c++ files for
+  				which dependencies will be checked.
+  				(This can be achieved with: make depend)
+  		BIN_LINK	this gives commands for additional
+  				libraries needed to link the application
+  ---------------------------------------------------------------------------
+  bin2	  creates two local binaries (for global binaries prefix bin2 with g)
+  	  in addition to the variables specified above you MUST also
+  	  provide the same variables with BIN2_ instead of BIN_
+  ---------------------------------------------------------------------------
+  lib	  creates a local library (for a global binary prefix bin with g)
+  	  additional variables needed:
+  		LIB_TARGET	this gives the name of your library
+  		LIB_OBJ		this gives the object files needed for
+  				the library to be build.
+  	  optional variables are:
+  		LIB_SRC		this gives the list of c/c++ files for
+  				which dependencies will be checked.
+  	  libbin and libgbin are also possible and will need in addition
+  	  the variables from bin
+  ---------------------------------------------------------------------------
+  gslib	  is similar to lib, but it creates a shared library if the system
+  	  supports it.
+  	  additional variables needed:
+  		LIB_MAJOR	major number of the shared library
+  		LIB_MINOR	minor number of the shared library
+  ---------------------------------------------------------------------------
+  other additional variables:
+
+  	  ADD_COMPILE	   define additional includes/defines that
+  			   are needed to compile the object files
+  			   (if you need to reference some directory
+  			   utils - like wxGrid -, then please 
+  			   reference them with the variables defined
+  			   in template.mak - e.g.: $(SRCDIR),$(UTILS),
+  			   $(SAMPLES),$(OTHERS))
+
+  	  NEEDED_DEFINES   lists all the defines that HAVE to be set in
+  			   /include/wx/setup.h to compile correctly.
+
+	  SRC_DIR	   lists all directories that are needed to
+			   compile. (i.e: lists all the directories,
+			   where there are source-files.) But it is 
+			   also needed to clean an object and for 
+			   machines, for which make does not support 
+			   VPATH
+
+currently there are the following compiling rules provided:
+object files are created for the following file extensions:
+.c .cc .cpp
+
+Please have a closer look at the Makefiles in this distribution.
+
+* Platforms configure is working with
+---------------------------------------
+
+Please report build succes on any machine. Especially non-
+Linux operating systems (which I don't have).
+
+Original author of the autoconf system for wxxt-1.66 and for this INSTALL
+file:
+
+	Martin Sperl	sperl@dsn.ast.univie.ac.at
+	
+Ported to wxGTK 0.1:
+
+	Wolfram Gloger  wmglo@dent.med.uni-muenchen.de
+
+Thanks alot to both of them.
+
+In the hope that it will be useful,
+
+        Robert Roebling roebling@sun2.ruf.uni-freiburg.de
+	
+	

docs/gtk/licence.txt

@@ -0,0 +1,56 @@
+
+
+wxWindows Library License, Version 3
+====================================
+     
+  Copyright (C) 1998 Julian Smart, Robert Roebling et al. 
+
+  Everyone is permitted to copy and distribute verbatim copies
+  of this license document, but changing it is not allowed. 
+ 
+                          WXWINDOWS LIBRARY LICENSE 
+     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+ 
+  This library is free software; you can redistribute it and/or modify it 
+  under the terms of the GNU Library General Public License as published by 
+  the Free Software Foundation; either version 2 of the License, or (at 
+  your option) any later version. 
+   
+  This library is distributed in the hope that it will be useful, but 
+  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- 
+  TABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library 
+  General Public License for more details. 
+ 
+  You should have received a copy of the GNU Library General Public License 
+  along with this software, usually in a file named COPYING.LIB.  If not,   
+  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,  
+  Boston, MA 02111-1307 USA. 
+ 
+  EXCEPTION NOTICE 
+ 
+  1. As a special exception, the copyright holders of this library give 
+  permission for additional uses of the text contained in this release of 
+  the library as licensed under the wxWindows Library License, applying 
+  either version 3 of the License, or (at your option) any later version of 
+  the License as published by the copyright holders of version 3 of the 
+  License document. 
+ 
+  2. The exception is that you may create binary object code versions of any 
+  works using this library or based on this library, and use, copy, modify, 
+  link and distribute such binary object code files unrestricted under terms 
+  of your choice. 
+ 
+  3. If you copy code from files distributed under the terms of the GNU 
+  General Public License or the GNU Library General Public License into a 
+  copy of this library, as this license permits, the exception does not   
+  apply to the code that you add in this way.  To avoid misleading anyone as 
+  to the status of such modified files, you must delete this exception 
+  notice from such code and/or adjust the licensing conditions notice  
+  accordingly. 
+ 
+  4. If you write modifications of your own for this library, it is your 
+  choice whether to permit this exception to apply to your modifications. 
+  If you do not wish that, you must delete the exception notice from such 
+  code and/or adjust the licensing conditions notice accordingly. 
+
+  

docs/gtk/readme.txt

@@ -0,0 +1,36 @@
+
+  Welcome to wxWindows/Gtk,
+  
+you have downloaded version 1.96 of the GTK+ port of C++ library
+wxWindows. Information on how to install can be found in the
+file install.txt, but if you cannot wait, this should work on
+all systems
+
+configure --without-threads
+make
+su (PASSWORD)
+make install
+
+wxWindows/Gtk is still in development and you can have a look
+at the todo.txt to see what's missing before an official beta
+and - more important - before we can aim at binary compatibility.
+
+More information is available from my homepage at
+
+  http://wesley.informatik.uni-freiburg.de/~wxxt
+  
+Please send problems concerning installation, feature requests, 
+bug reports or comments to either the wxGTK mailing list or to
+the wxWindows developers list. Information on how to subscribe
+is available from my homepage.
+
+wxWindows/Gtk comes with no guarantee whatsoever. It might crash
+your harddisk or destroy your monitor. It doesn't claim to be
+suitable for any special purpose.
+
+  Regards,
+
+    Robert Roebling
+
+
+

docs/gtk/todo.txt

@@ -0,0 +1,38 @@
+
+-------------------- High priority ---------------------
+
+wxTreeCtrl
+  -> Keyboard handling.
+
+wxClipboard
+  -> On the way, but not functional yet.
+  
+Fix printing of bitmaps
+  -> No idea.
+
+OwnerDraw for wxListCtrl and others
+  -> That is a big one.
+  
+DnD
+  -> Must be rewritten for GTK+ 1.1.3  
+ 
+-------------------- Low priority ---------------------
+    
+wxDebugContext <-> wxLogXXX functions
+  -> Remove either
+
+Implement wxPalette
+  -> I never understood that. Postponed.
+  
+Implement wxDirDialog
+  -> Not heard of. Postponed.
+
+Show accelerator in menus
+  -> Changed in GTK 1.1.X. Postponed.
+  
+Correct tab navigation
+  -> seems to be broken in GTK. Postponed.
+  
+Cooperation with Qt
+  -> Would be nice.
+  

docs/gtk/welcome.html

@@ -0,0 +1,292 @@
+<html>
+<head><title>wxGTK Homepage</title>
+</head>
+<body bgcolor=#FFFFFF text=#000000 link=#0020FF vlink=#800000 alink=#007777>
+<h1>"wxWindows for the GTK" Homepage</h1>
+
+<hr>
+<h3>Current version</h3>
+15th May '98: wxGTK v0.12 (alpha-)
+<p> 
+This release is hardly more stable than the one before, but it
+has many new features. It's main purpose is actually to prepare
+the final merge of the Windows port and the GTK port source
+trees into a common tree, developed using CVS. The growing
+number of demos which compile and run with wxGTK "although"
+being written for wxMSW shows that we seem to be on the right
+track. One nice new feature for many potential users is that
+wxGTK no longer needs any extra libraries to be installed,
+other than the GTK.
+<p>
+If you have a compiler
+better than gcc 2.7.2.2 then you can uncomment a line in src/common/prntbase.cpp
+which defines __GOOD_COMPILER__. This should make the printing demo work.
+I haven't got such a compiler, so I actually don't know. Somebody reported
+problems with version 2.7.2.3 as well.
+<p>
+<hr>
+<h3>Acknowledgements</h3>
+I'd like to thank the 
+<a href="http://www.freiburg.linux.de">Freiburg Linux User Group</a>
+ for kindly providing
+this site and Christian Wetzel in particular for helping me with
+this site's administration.
+<p>
+
+<hr>
+<h3>What is wxWindows?</h3>
+wxWindows is a C++ cross-platform GUI toolkit written mainly by Julian Smart. 
+More information about wxWindows can be found at the
+<a href="http://web.ukonline.co.uk/julian.smart/wxwin">wxWindows Homepage</a>.
+
+<p>
+The current version of wxWindows (v1.68) supports Windows ('95 and NT), Motif and
+XView (aka OpenLook). There is another port (wxXt) available, which uses the 
+free-ware widget set from the Free Widget Foundation (FSF). Ports have been
+started for the Mac, OS/2 and NextStep.
+<p>
+For different reasons, it was decided to start a complete rewrite of wxWindows,
+which will then be called wxWindows 2.0. For a list of new features and changes
+from the current version, you may read the wxWindows Homepage (see above).
+<p>
+Currently, work is being done on four ports of wxWindows 2.0:
+<dl>
+  <li> Windows (wxMSW, main author Julian Smart)
+  <li> Unix, Motif (wxMotif, main author Markus Holzhem)
+  <li> Unix, GIMP Toolkit (wxGTK, main author Robert Roebling)
+  <li> Macintosh (wxMac, main author Greg Whitehead)
+</dl>
+<p>
+wxWindows provides a rich set of classes which help to make cross-platform
+GUI programming easy. In many aspect, it is modelled after MFC, making transition
+from MFC to wxWindows relatively painless. The main technical
+difference between most other free or commercial cross platform libraries is
+that wxWindows is a wrapper around existing widget sets, whereas the other
+toolkits (Qt, Tk, Java, Amulet, OPaC, JX, Fresko) draw their widgets themselves, 
+which results in applications having a different look than native applications 
+for that specific platform.
+<p>
+There are classes for the following categories
+<dl>
+  <li> Window classes: wxWindow, wxFrame, wxDialogBox, wxPanel, wxCanvas etc.
+  <li> Widget classes: wxButton, wxCheckbox, wxChoice, wxListBox, wxListCtrl, wxText, wxGauge etc.
+  <li> Data structures: wxList, wxString, wxHashTable, wxDate etc.
+  <li> Layout/constraint system
+  <li> GDI classes: wxPen, wxBrush, wxFont, wxBitmap etc.
+  <li> Events: wxCommandEvent, wxMouseEvent, wxKeyEvent etc.
+  <li> Devices contexts: wxCanvasDC, wxPostScriptDC, wxMemoryDC, wxPrinterDC
+  <li> Base classes for runtime-type information: wxObject
+  <li> Interprocess communication: wxClient, wxConnection, wxSocket, wxServer etc.
+  <li> Document-view architecture: wxDocument, wxView, wxDocManager etc.
+  <li> Printing framework: wxPreviewFrame, wxPrintDialog, wxPrinter etc.
+  <li> Many helper classes, wxApplication, wxTypeTree, wxPathList etc.
+  <li> Classes for internationalization
+  <li> Built-in memory leak checking, log-files
+  <li> A multitude of functions and macros
+</dl>
+
+<hr>
+<h3>Copyright</h3>
+The choice of a suitable copyright has been subject to endless discussions. It
+has always been the aim, to put wxWindows under a copyright, which protects
+the work of its authors while at the same time encouraging the use of wxWindows
+in as many projects as possible. 
+<p>
+The (so far) last decision has been to put the whole of wxWindows
+under a modified (less restrictive) version of the GNU library general 
+public license.
+<p>
+The only exception is that wxGTK now contains code (gdk_imlib) which is 
+under the GNU library general public license. When you make changes to 
+this part of wxGTK, you'll have to make these changes public (in contrast 
+to changes to the rest).
+<p>
+It is obviously encouraged that anybody who uses wxWindows and who
+makes any improvements to it will make these changes available to
+wxWindows' authors.
+<p>
+<hr>
+<h3>What can I do with wxWindows 2.0?</h3>
+wxWindows is still in alpha stage, which means that there are still bugs
+waiting for you and several features are not yet (fully) implemented, but
+you can expect the interface to be more or less stable, so no major 
+modifications will have to be made to your source code. wxGTK is already
+used in a number of medium sized projects and is it being developped
+in close cooperation with the authors of these applications.
+<p>
+<hr>
+<h3>Can I write a GNOME application with wxGTK 2.0?</h3>
+Good question. The idea to use wxGTK for the GNOME desktop environment is
+quite obvious. When this topic came up on the GNOME mailing list, the GNOME
+people have shown an amazingly negative opinion about wxWindows. One reason
+might be that several of the main authors of the GNOME-project consider
+C++ a "broken language". I don't share that view and I am sure many people
+find C++ easier to handle and better suited for GUI programming than C.
+<p>
+Just recently, the topic of C++ in general and wxGTK in particular appeared
+again on the GNOME list. It has shown that - at least - the opinion on C++
+on the GNOME list is split. 
+<p>
+There is already a C++ wrapper for the GTK called GTK-- written by Tero Pulkkinen. 
+It is very small and adds very little overhead to the GTK. If platform
+independence is no issue for you and you want to write a small tool
+for Linux, you should probably use GTK--. Of course you can use wxGTK
+for that, too :-)
+<p>
+<hr>
+<h3>Screenshots</h3>
+What would a home page of a GUI be without a screenshot? Well, as wxWindows
+is a wrapper around existing widget/item sets, a wxWindows application will
+look like any other native Windows, Motif, GTK or Mac application.
+<p>
+But for those of you, who wouldn't download wxGTK only because there
+is no screenshot, 
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt/sshot.jpg">here it comes</a>.
+<p>
+<hr>
+<h3>Download 1.68</h3>
+Go to the 
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt">FTP</a>
+section directly.
+<p>
+There is documentation for version 1.68 in html available. 
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt">here</a>. Not yet.
+<p>
+You can download current wxWindows version 1.68 for Windows, Motif and
+XView from
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt">here</a>. Not yet.
+<p>
+You can download wxXt 1.66d from
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt/wxxt166d.tgz">here</a>.
+<p>
+<hr>
+<h3>Download 2.0 alpha</h3>
+There is documentation for version 2.0 in html available. 
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt/wxGTK_doc.tgz">here</a>.
+<p>
+You can download the first alpha for wxWindows 2.0 for Windows from
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt/">here</a>. Not yet.
+<p>
+You can download the current alpha for wxWindows 2.0 for GTK from
+<a href="ftp://ftp.freiburg.linux.de/pub/linux/wxxt/wxGTK-0.12.tgz">here</a>. 
+<p>
+
+<hr>
+<h3>News from wxGTK 0.12</h3>
+<p>
+PNG, zlib and gdk_imlib code included.
+<p>
+MDI implementation. More a basis for further testing
+than of real value.
+<p>
+Split "--with-debug" option into two options: "--with-debug_info"
+and "--with-debug_flag". The first one sets the "-g" flag when
+compiling, the second defines "DEBUG" in setup.h (which is included
+from defs.h).
+<p>
+Merged DocView framework. The sample doesn't compile yet, because
+it uses features from wxTextCtrl, which I haven't implemented yet.
+<p>
+Merged TabCtrl. Doesn't look perfect, but it seems to work.
+<p>
+Merged remaining classes from the newest wxMSW alpha. (wxDynArray,
+wxModule etc.).
+<p>
+Further updates, bug fixes or additions:
+<p>
+<dl>
+  <li> wxYield() (again)
+  <li> postscript support for bitmaps
+  <li> spline code merged
+  <li> several bug fixes
+  <li> new samples
+</dl>
+
+<p>
+<hr>
+<h3>Known problems</h3>
+
+Missing implementation of:
+<dl>
+  <li>Impossible to set new font in GTK's widgets
+  <li>Items containing bitmaps
+  <li>Masks, bitmap handlers (partially done)
+  <li>Gauge
+  <li>Combobox
+  <li>Palettes (colormaps)
+  <li>Keyboard accelerators for menus
+  <li>Validation
+  <li>Clipboard functions
+  <li>Resources (for use with wxIDE-to-be)
+  <li>Drag and Drop
+  <li>Threads, Interprocess communication
+  <li>Sockets
+  <li>Database classes
+</dl>
+
+<p>
+<hr>
+<h3>Installation of wxGTK under Linux</h3>
+
+GTK requires an up-to-date version of the 
+<dl>
+  <li> GTK (GIMP ToolKit)
+</dl>
+to be installed as a shared lib on your system. wxGTK is being developped with
+version 1.0.1 and it is known not to work with earlier versions.
+The GTK library is available from 
+<a href="ftp://ftp.gtk.org/pub/">somewhere here (gtk.org).</a>
+After having typed "make install" the GTK header files should be
+in "/usr/local/include". Correct me, if I am wrong.
+<p>
+Compilation itself works as usual with autoconf:
+<dl>
+  <li> Unpack it to a suitable subdirectory, let's say ~/wxGTK
+  <li> Type "cd wxGTK"
+  <li> Type "configure"
+  <li> Type "make"
+</dl>
+Some demos use files stored in the source directory of those demos
+(e.g. internat uses files in samples/internat) whereas the binaries
+will end up in samples/internat/linux. You'll have to copy the binaries
+down or call them like "linux/test" from samples/internat. This is
+also the case for wxTest (which should display a horse).
+<p>
+You can create a shared library by adding the option "--with-shared" to
+the "configure" command. Afterwards, you'll have to copy the library
+~/wxGTK/lib/linux (if you have Linux) to a directory in your LDPATH (e.g. /usr/X11R6/lib)
+and run "ldconfig".
+<p>
+
+<hr>
+<h3>Mailing list for wxGTK</h3>
+The mailing list (as well as this page) is called wxxt for more
+or less historical reasons.
+<p>
+You can subsribe to the mailing list by sending a mail to
+<a href="mailto:majordomo@wesley.informatik.uni-freiburg.de">majordomo@wesley.informatik.uni-freiburg.de</a>.
+This mail must contain the text "subscribe wxxt" in the body (not the subject) of the
+mail. You will then get a confirmation that somebody asked majordomo to put you
+on the list and you will have to confirm this once again by sending back
+the authentisation, which comes in the confirmation mail. The last step
+is also described in the actual confirmation mail (I think).
+<p>
+You can send a mail to the mailing list to the address
+<a href="mailto:wxxt@www.freiburg.linux.de">wxxt@www.freiburg.linux.de</a>.
+
+<p>
+Unsubscribe by sending "unsubscribe wxxt" to majordomo (see above). Not to
+the actual mailing list.
+<p>
+<hr>
+<address>
+<br>This page is maintained by <a href="mailto:roebling@sun2.ruf.uni-freiburg.de">Robert Roebling</a>.
+Comments, in contrast to junk and flames, welcome.
+<p>
+Last changed 15th Mai '98. 
+</address>
+</body>
+</html>
+
+
+

docs/latex/porting/porting.hpj

@@ -0,0 +1,16 @@
+[OPTIONS]
+TITLE=wxWindows Porting Guide
+CONTENTS=Contents
+COMPRESS=HIGH
+
+[FILES]
+porting.rtf
+
+[CONFIG]
+CreateButton("Up", "&Up", "JumpId(`porting.hlp', `Contents')")
+BrowseButtons()
+
+[MAP]
+
+[BITMAPS]
+

docs/latex/porting/porting.tex

@@ -0,0 +1,390 @@
+\documentstyle[a4,makeidx,verbatim,texhelp,fancyhea,mysober,mytitle]{report}
+\newcommand{\indexit}[1]{#1\index{#1}}%
+\newcommand{\pipe}[0]{$\|$\ }%
+\definecolour{black}{0}{0}{0}%
+\definecolour{cyan}{0}{255}{255}%
+\definecolour{green}{0}{255}{0}%
+\definecolour{magenta}{255}{0}{255}%
+\definecolour{red}{255}{0}{0}%
+\definecolour{blue}{0}{0}{200}%
+\definecolour{yellow}{255}{255}{0}%
+\definecolour{white}{255}{255}{255}%
+\input psbox.tex
+\parskip=10pt
+\parindent=0pt
+\title{Guide to porting applications from wxWindows 1.xx to 2.0}
+\author{Julian Smart}
+\date{October 1997}
+\makeindex
+\begin{document}
+\maketitle
+\pagestyle{fancyplain}
+\bibliographystyle{plain}
+\setheader{{\it CONTENTS}}{}{}{}{}{{\it CONTENTS}}
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+\pagenumbering{roman}
+\tableofcontents
+%
+\chapter{About this document}\label{about}
+\pagenumbering{arabic}%
+\setheader{{\it Porting guide}}{}{}{}{}{{\it Porting guide}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+
+This document gives guidelines and tips for porting applications from
+version 1.xx of wxWindows to version 2.0.
+
+The first section offers tips for writing 1.xx applications in a way to
+minimize porting time. The following sections detail the changes and
+how you can modify your application to be 2.0-compliant.
+
+You may be worrying that porting to 2.0 will be a lot of work,
+particularly if you have only recently started using 1.xx. In fact,
+the wxWindows 2.0 API has far more in common with 1.xx than it has differences.
+With backward compatibility mode on, much of the conversion can be
+done gradually. The main challenges are doing without the default
+panel item layout, and the lack of automatic labels in some controls.
+However, if you already use resource files (.wxr), or application-specific positioning,
+or constraints, then even this will be quite painless.
+
+So please don't be freaked out by the jump to 2.0! For one thing, 1.xx is still available
+and will be supported by the user community for some time. And when you have
+changed to 2.0, we hope that you will appreciate the benefits in terms
+of greater flexibility, better user interface aesthetics, improved C++ conformance,
+improved compilation speed, and many other enhancements. The revised architecture
+of 2.0 will ensure that wxWindows can continue to evolve for the forseeable
+future.
+
+{\it Please note that this document is a work in progress.}
+
+\chapter{Preparing for version 2.0}\label{preparing}
+
+Even before compiling with version 2.0, there's also a lot you can do right now to make porting
+relatively simple. Here are a few tips.
+
+\begin{itemize}
+\item {\bf Use constraints or .wxr resources} for layout, rather than the default layout scheme.
+Constraints should be the same in 2.0, and resources will be translated.
+\item {\bf Use separate wxMessage items} instead of labels for wxText, wxMultiText,
+wxChoice, wxComboBox. These labels will disappear in 2.0. Use separate
+wxMessages whether you're creating controls programmatically or using
+the dialog editor. The future dialog editor will be able to translate
+from old to new more accurately if labels are separated out.
+\item {\bf Parameterise functions that use wxDC} or derivatives, i.e. make the wxDC
+an argument to all functions that do drawing. Minimise the use of
+wxWindow::GetDC and definitely don't store wxDCs long-term
+because in 2.0, you can't use GetDC() and wxDCs are not persistent.
+You will use wxClientDC, wxPaintDC stack objects instead. Minimising
+the use of GetDC() will ensure that there are very few places you
+have to change drawing code for 2.0.
+\item {\bf Don't set GDI objects} (wxPen, wxBrush etc.) in windows or wxCanvasDCs before they're
+needed (e.g. in constructors) - do so within your drawing routine instead. In
+2.0, these settings will only take effect between the construction and destruction
+of temporary wxClient/PaintDC objects.
+\item {\bf Don't rely} on arguments to wxDC functions being floating point - they will
+be 32-bit integers in 2.0.
+\item {\bf Don't use the wxCanvas member functions} that duplicate wxDC functions, such as SetPen and DrawLine, since
+they are going.
+\item {\bf Using member callbacks} called from global callback functions will make the transition
+easier - see the FAQ
+for some notes on using member functions for callbacks. wxWindows 2.0 will banish global
+callback functions (and OnMenuCommand), and nearly all event handling will be done by functions taking a single event argument.
+So in future you will have code like:
+
+{\small\begin{verbatim}
+void MyFrame::OnOK(wxCommandEvent& event)
+{
+        ...
+}
+\end{verbatim}
+}%
+
+You may find that writing the extra code to call a member function isn't worth it at this stage,
+but the option is there.
+\item {\bf Use wxString wherever possible.} 2.0 will replace char * with wxString
+in most cases, and if you use wxString to receive strings returned from
+wxWindows functions (except when you need to save the pointer if deallocation is required), there should
+be no conversion problems later on.
+\item Be aware that under Windows, {\bf font sizes will change} to match standard Windows
+font sizes (for example, a 12-point font will appear bigger than before). Write your application
+to be flexible where fonts are concerned.
+Don't rely on fonts being similarly-sized across platforms, as they were (by chance) between
+Windows and X under wxWindows 1.66. Yes, this is not easy... but I think it's better to conform to the
+standards of each platform, and currently the size difference makes it difficult to
+conform to Windows UI standards. You may eventually wish to build in a global 'fudge-factor' to compensate
+for size differences. The old font sizing will still be available via wx\_setup.h, so do not panic...
+\item {\bf Consider dropping wxForm usage}: an alternative is to be found in utils/wxprop.
+wxPropertyFormView can be used in a wxForm-like way, except that you specify a pre-constructed panel
+or dialog; or you can use a wxPropertyListView to show attributes in a scrolling list - you don't even need
+to lay panel items out.
+
+Because wxForm uses a number of features to be dropped in wxWindows 2.0, it cannot be
+supported in the future, at least in its present state.
+\item {\bf When creating a wxListBox}, put the wxLB\_SINGLE, wxLB\_MULTIPLE, wxLB\_EXTENDED styles in the window style parameter, and put
+zero in the {\it multiple} parameter. The {\it multiple} parameter will be removed in 2.0.
+\item {\bf For MDI applications}, don't reply on MDI being run-time-switchable in the way that the
+MDI sample is. In wxWindows 2.0, MDI functionality is separated into distinct classes.
+\end{itemize}
+
+\chapter{The new event system}\label{eventsystem}
+
+The way that events are handled has been radically changed in wxWindows 2.0. Please
+read the topic `Event handling overview' in the wxWindows 2.0 manual for background
+on this.
+
+\section{Callbacks}
+
+Instead of callbacks for panel items, menu command events, control commands and other events are directed to
+the originating window, or an ancestor, or an event handler that has been plugged into the window
+or its ancestor. Event handlers always have one argument, a derivative of wxEvent.
+
+For menubar commands, the {\bf OnMenuCommand} member function will be replaced by a series of separate member functions,
+each of which responds to a particular command. You need to add these (non-virtual) functions to your
+frame class, add a DECLARE\_EVENT\_TABLE entry to the class, and then add an event table to
+your implementation file, as a BEGIN\_EVENT\_TABLE and END\_EVENT\_TABLE block. The
+individual event mapping macros will be of the form:
+
+\begin{verbatim}
+BEGIN_EVENT_TABLE(MyFrame, wxFrame)
+    EVT_MENU(MYAPP_NEW, MyFrame::OnNew)
+    EVT_MENU(wxID_EXIT, MyFrame::OnExit)
+END_EVENT_TABLE()
+\end{verbatim}
+
+Control commands, such as button commands, can be routed to a derived button class,
+the parent window, or even the frame. Here, you use a function of the form EVT\_BUTTON(id, func).
+Similar macros exist for other control commands.
+
+\section{Other events}
+
+To intercept other events, you used to override virtual functions, such as OnSize. Now, while you can use
+the OnSize name for such event handlers (or any other name of your choice), it has only a single argument
+(wxSizeEvent) and must again be `mapped' using the EVT\_SIZE macro. The same goes for all other events,
+including OnClose (although in fact you can still use the old, virtual form of OnClose for the time being).
+
+\chapter{Class hierarchy}\label{classhierarchy}
+
+The class hierarchy has changed somewhat. wxToolBar and wxButtonBar
+classes have been split into several classes, and are derived from wxControl (which was
+called wxItem). wxPanel derives from wxWindow instead of from wxCanvas, which has
+disappeared in favour of wxScrolledWindow (since all windows are now effectively canvases
+which can be drawn into). The status bar has become a class in its own right, wxStatusBar.
+
+There are new MDI classes so that wxFrame does not have to be overloaded with this
+functionality.
+
+There are new device context classes, with wxPanelDC and wxCanvasDC disappearing.
+See \helpref{Device contexts and painting}{dc}.
+
+\chapter{GDI objects}\label{gdiobjects}
+
+These objects - instances of classes such as wxPen, wxBrush, wxBitmap (but not wxColour) -
+are now implemented with reference-counting. This makes assignment a very cheap operation,
+and also means that management of the resource is largely automatic. You now pass {\it references} to
+objects to functions such as wxDC::SetPen. The device context does not store a copy of the pen
+itself, but takes a copy of it (via reference counting), and the object's data gets freed up
+when the reference count goes to zero. The application does not have to worry so much about
+who the object belongs to: it can pass the reference, then destroy the object without
+leaving a dangling pointer inside the device context.
+
+For the purposes of code migration, you can use the old style of object management - maintaining
+pointers to GDI objects, and using the FindOrCreate... functions. However, it is preferable to
+keep this explicit management to a minimum, instead creating objects on the fly as needed, on the stack,
+unless this causes too much of an overhead in your application.
+
+At a minimum, you will have to make sure that calls to SetPen, SetBrush etc. work. Some compilers
+will do the conversion from pointer to reference automatically (via a constructor in the GDI
+class) but you cannot rely on this being true for all compilers. Also, where you pass NULL to these
+functions, you will need to either cast to the appropriate reference type, or instead
+use an identifier such as wxNullPen or wxNullBrush.
+
+\chapter{Dialogs and controls}\label{dialogscontrols}
+
+\wxheading{Labels}
+
+Most controls no longer have labels and values as they used to in 1.xx. Instead, labels
+should be created separately using wxStaticText (the new name for wxMessage). This will
+need some reworking of dialogs, unfortunately; programmatic dialog creation that doesn't
+use constraints will be especially hard-hit. Perhaps take this opportunity to make more
+use of dialog resources or constraints. Or consider using the wxPropertyListView class
+which can do away with dialog layout issues altogether by presenting a list of editable
+properties.
+
+\wxheading{Constructors}
+
+All window constructors have two main changes, apart from the label issue mentioned above.
+Windows now have integer identifiers; and position and size are now passed as wxPoint and
+wxSize objects. In addition, some windows have a wxValidator argument. wxWindows 2.0 may provide
+old-style constructors in WXWIN\_COMPATIBILITY mode for limited backward compatibility.
+
+\wxheading{Show versus ShowModal}
+
+If you have used or overridden the {\bf wxDialog::Show} function in the past, you may find
+that modal dialogs no longer work as expected. This is because the function for modal showing
+is now {\bf wxDialog:ShowModal}. This is part of a more fundamental change in which a
+control may tell the dialog that it caused the dismissal of a dialog, by
+calling {\bf wxDialog::EndModal} or {\bf wxWindow::SetReturnCode}. Using this
+information, {\bf ShowModal} now returns the id of the control that caused dismissal,
+giving greater feedback to the application than just TRUE or FALSE.
+
+If you overrode or called {\bf wxDialog::Show}, use {\bf ShowModal} and test for a returned identifier,
+commonly wxID\_OK or wxID\_CANCEL.
+
+\wxheading{wxItem}
+
+This is renamed wxControl.
+
+\wxheading{wxText, wxMultiText and wxTextWindow}
+
+These classes no longer exist and are replaced by the single class wxTextCtrl.
+Multi-line text items are created using the wxTE\_MULTILINE style.
+
+\wxheading{wxButton}
+
+Bitmap buttons are now a separate class, instead of being part of wxBitmap.
+
+\wxheading{wxMessage}
+
+Bitmap messages are now a separate class, wxStaticBitmap, and wxMessage
+is renamed wxStaticText.
+
+\wxheading{wxGroupBox}
+
+wxGroupBox is renamed wxStaticBox.
+
+\wxheading{wxForm}
+
+Note that wxForm is no longer supported in wxWindows 2.0. Consider using the wxPropertyForm class
+instead, which takes standard dialogs and panels and associates controls with property objects.
+You may also find that the new validation method, combined with dialog resources, is easier
+and more flexible than using wxForm.
+
+\chapter{Device contexts and painting}\label{dc}
+
+In wxWindows 2.0, device contexts are used for drawing into, as per 1.xx, but the way
+they are accessed and constructed is a bit different.
+
+You no longer use {\bf GetDC} to access device contexts for panels, dialogs and canvases.
+Instead, you create a temporary device context, which means that any window or control can be drawn
+into. The sort of device context you create depends on where your code is called from. If
+painting within an {\bf OnPaint} handler, you create a wxPaintDC. If not within an {\bf OnPaint} handler,
+you use a wxClientDC or wxWindowDC. You can still parameterise your drawing code so that it
+doesn't have to worry about what sort of device context to create - it uses the DC it is passed
+from other parts of the program.
+
+You {\bf must } create a wxPaintDC if you define an OnPaint handler, even if you do not
+actually use this device context, or painting will not work correctly under Windows.
+
+If you used device context functions with wxPoint or wxIntPoint before, please note
+that wxPoint now contains integer members, and there is a new class wxRealPoint. wxIntPoint
+no longer exists.
+
+\chapter{Miscellaneous}
+
+\section{Strings}
+
+wxString has replaced char* in the majority of cases. For passing strings into functions,
+this should not normally require you to change your code if the syntax is otherwise the
+same. This is because C++ will automatically convert a char* or const char* to a wxString by virtue
+of appropriate wxString constructors.
+
+However, when a wxString is returned from a function in wxWindows 2.0 where a char* was
+returned in wxWindows 1.xx, your application will need to be changed. Usually you can
+simplify your application's allocation and deallocation of memory for the returned string,
+and simply assign the result to a wxString object. For example, replace this:
+
+{\small\begin{verbatim}
+  char* s = wxFunctionThatReturnsString();
+  s = copystring(s); // Take a copy in case it's temporary
+  .... // Do something with it
+  delete[] s;
+\end{verbatim}
+}
+
+with this:
+
+{\small\begin{verbatim}
+  wxString s = wxFunctionThatReturnsString();
+  .... // Do something with it
+\end{verbatim}
+}
+
+To indicate an empty return value or a problem, a function may return either the
+empty string (``") or a null string. You can check for a null string with wxString::IsNull().
+
+\section{Use of const}
+
+The {\bf const} keyword is now used to denote constant functions that do not affect the
+object, and for function arguments to denote that the object passed cannot be changed.
+
+This should not affect your application except for where you are overriding virtual functions
+which now have a different signature. If functions are not being called which were previously,
+check whether there is a parameter mismatch (or function type mismatch) involving consts.
+
+Try to use the {\bf const} keyword in your own code where possible.
+
+\chapter{Backward compatibility}\label{compat}
+
+Some wxWindows 1.xx functionality has been left to ease the transition to 2.0. This functionality
+(usually) only works if you compile with WXWIN\_COMPATIBILITY set to 1.
+
+TODO
+
+OnMenuCommand, OnSize, OnActivate, OnPaint, others?? can all be prefixed with Old (e.g. OldOnMenuCommand)
+and will work as before. You are encouraged to convert your code to the new forms, but
+this will allow you to get your applications up and running a little more quickly.
+
+OnClose can be used as-is without an 'Old' prefix, but officially the OnCloseWindow event table handler should be
+used instead.
+
+\chapter{Quick reference}\label{quickreference}
+
+This section allows you to quickly find features that
+need to be converted.
+
+TODO
+
+\section{OnActivate}
+
+Rename to OldOnActivate, or replace arguments with one wxActivateEvent\& argument.
+
+\wxheading{See also}
+
+\helpref{Backward compatibility}{compat}
+
+\section{OnClose}
+
+This can either remain the same as before, or you can add an OnCloseWindow event
+handler using an EVT\_CLOSE event table entry.
+
+\wxheading{See also}
+
+\helpref{Backward compatibility}{compat}
+
+\section{OnMenuCommand}
+
+Rename to OldOnMenuCommand, or replace with a series of functions, one for
+each case of your old switch statement. Create an event table for your frame
+containing EVT\_MENU macros, and insert DECLARE\_EVENT\_TABLE() in your frame class.
+
+\wxheading{See also}
+
+\helpref{Backward compatibility}{compat}
+
+\section{OnSize}
+
+Rename to OldOnSize, or replace arguments with one wxSizeEvent\& argument.
+
+\wxheading{See also}
+
+\helpref{Backward compatibility}{compat}
+
+\section{wxDialog::Show}
+
+If you used {\bf Show} to show a modal dialog, or to override the standard
+modal dialog {\bf Show}, use {\bf ShowModal} instead.
+
+\wxheading{See also}
+
+\helpref{Dialogs and controls}{dialogscontrols}
+
+\end{document}

docs/latex/porting/tex2rtf.ini

@@ -0,0 +1,28 @@
+;;; Tex2RTF initialisation file for 16-bit Winhelp
+runTwice = yes
+titleFontSize = 12
+authorFontSize = 10
+authorFontSize = 10
+chapterFontSize = 12
+sectionFontSize = 12
+subsectionFontSize = 12
+contentsDepth = 2
+headerRule = yes
+footerRule = yes
+useHeadingStyles = yes
+listItemIndent=40
+generateHPJ = no
+htmlBrowseButtons = bitmap
+winHelpContents = yes
+winHelpVersion = 3 ; 3 for Windows 3.x, 4 for Windows 95
+winHelpTitle = "wxWindows Porting Guide"
+truncateFilenames = yes
+combineSubSections = yes
+\overview [2] {\rtfonly{See also }\settransparency{on}\sethotspotcolour{off}\sethotspotunderline{on}\winhelponly{\image{}{books.bmp}\settransparency{off}}
+\htmlonly{\image{}{books.gif}}\helpref{#1}{#2}
+\sethotspotcolour{on}\sethotspotunderline{on}}
+\docparam [2]{\parskip{0}{\it #1}\par\parskip{10}\indented{1cm}{#2}}
+\wxheading [1]{{\bf \fcol{blue}{#1}}}
+\const [0] {{\bf const}}
+\constfunc [3] {{\bf #1} {\bf #2}(#3) {\bf const}\index{#2}}
+

docs/latex/porting/texhelp.sty

@@ -0,0 +1,289 @@
+% LaTeX style file
+% Name:   texhelp.sty
+% Author: Julian Smart
+%
+% Purpose
+% -------
+% Style file to enable the simultaneous preparation of printed LaTeX and on-line
+% hypertext manuals.
+% Use in conjunction with Tex2RTF (see Tex2RTF documentation).
+%
+% Note that if a non-ASCII character starts a newline and there should be a space
+% between the last word on the previous line and the first word on this line,
+% you need to use \rtfsp to generate a space in Windows Help. \rtfsp is ignored
+% in all other formats.
+%
+% Julian Smart
+% Artificial Intelligence Applications Institute
+%
+%
+% ============== C++/CLIPS Documentation Facilities ==============
+%
+% Each class definition should be typeset with e.g.
+%
+% \section{\class{Name}: Parent}
+%
+% followed by a description of the class.
+% Each member should follow:
+%
+% \membersection{wxName::Member}
+%
+% with a description of what this member does.
+% Then, one (or more if overloaded) member (function) in detail:
+%
+% \func{return type}{name}{args}
+% or
+% \member{type}{name}
+%
+% where args is a list of \param{type}{name}, ...
+
+% Function, e.g.
+% e.g. to typeset
+%
+% void DoIt(char *string);
+%
+% write:
+%
+% \func{void}{DoIt}{\param{char *}{string}}
+%
+
+\newcommand{\func}[3]{\hangafter=1\noindent\hangindent=10mm
+{{\it #1} {\bf #2}\index{#2}}(#3)}
+
+% For function/type definition where the name is a pointer,
+% e.g. to typeset
+%
+% typedef void (*wxFunction)(wxObject&)
+%
+% write:
+%
+% \pfunc{typedef void}{wxFunction}{param{wxObject&}}
+
+\newcommand{\pfunc}[3]{\hangafter=1\noindent\hangindent=10mm
+{{\it #1} ({\bf *#2})\index{#2}}(#3)}
+
+% Use an ordinary \section command for class name definitions.
+
+% This is used for a member, such as wxBitmap: GetDepth
+\newcommand{\membersection}[1]{\subsection*{#1}\index{#1}}
+
+% CLIPS function
+\newcommand{\clipsfunc}[3]{\hangafter=1\noindent\hangindent=10mm
+{{\bf #1} ({\bf #2}\index{#2}}#3)}
+
+\newcommand{\clipssection}[1]{\chapter{#1}}
+
+% This is used for a CLIPS function name
+\newcommand{\functionsection}[1]{\subsection*{#1}}
+
+% Member: a type and a name
+\newcommand{\member}[2]{{\bf #1 \it #2}}
+
+% C++ Parameter: a type and a name (no intervening space)
+\newcommand{\param}[2]{{\it #1}{\bf #2}}
+
+% CLIPS Parameter: a type and a name (one intervening space)
+\newcommand{\cparam}[2]{{\bf #1} {\it #2}}
+
+% Class: puts in index
+\newcommand{\class}[1]{#1\index{#1}}
+
+% Void type
+\newcommand{\void}{{\it void}}
+
+% Typeset destructor
+\newcommand{\destruct}[1]{{$\sim$}#1}
+
+% Typeset insert/extract operators
+\newcommand{\cinsert}{$<<$}
+\newcommand{\cextract}{$>>$}
+
+
+% =================== Hypertext facilities ===================
+%
+% To insert hyperlinks (or references, in Latex), \label the sections
+% or membersections \label{ref-label} immediately after the section, on the same line,
+% and use \helpref{text-to-show}{ref-label} to make a reference.
+%
+
+% Type text with section reference
+\newcommand{\helpref}[2]{{\it #1} (p.\ \pageref{#2}) }
+
+% Type text with URL in verbatim mode
+\newcommand{\urlref}[2]{#1 (\verb$#2$)}
+
+% Don't typeset section number in LaTeX
+\newcommand{\helprefn}[2]{{\it #1}}
+
+% Like helpref, but popup text in WinHelp instead of hyperlinked
+\newcommand{\popref}[2]{{\it #1}}
+
+% Like footnote, but popup text.
+\newcommand{\footnotepopup}[2]{{\it #1}\footnote{#2}}
+
+% =================== On-line help specific macros ===================
+%
+
+% Global document font size/family, help only.
+\newcommand{\helpfontsize}[1]{}
+\newcommand{\helpfontfamily}[1]{}
+
+% Ignore in all on-line help
+\newcommand{\helpignore}[1]{#1}
+% Only print in all on-line help
+\newcommand{\helponly}[1]{}
+
+% Ignore in LaTeX
+\newcommand{\latexignore}[1]{}
+% Only print in LaTeX
+\newcommand{\latexonly}[1]{#1}
+
+% Ignore in linear RTF
+\newcommand{\rtfignore}[1]{#1}
+% Only print in linear RTF
+\newcommand{\rtfonly}[1]{}
+
+% Ignore in WinHelp RTF
+\newcommand{\winhelpignore}[1]{#1}
+% Only print in WinHelp RTF
+\newcommand{\winhelponly}[1]{}
+
+% Ignore in wxHelp
+\newcommand{\xlpignore}[1]{#1}
+% Only print in wxHelp
+\newcommand{\xlponly}[1]{}
+
+% Ignore in HTML
+\newcommand{\htmlignore}[1]{#1}
+% Only print in HTML
+\newcommand{\htmlonly}[1]{}
+
+% Input a file only for help system (binder thickness is not a limitation
+% in help systems!)
+\newcommand{\helpinput}[1]{}
+
+\newcommand{\rtfsp}{ } % Force a space in RTF, ignore in Latex
+
+% =================== Miscellaneous macros ===================
+%
+% Headings consistent with generated ones
+\newcommand{\myheading}[1]{\vspace*{25pt}
+\begin{flushleft}
+{\LARGE \bf #1}
+\end{flushleft}
+\vskip 20pt
+}
+
+% Heading with entry in contents page.
+\newcommand{\chapterheading}[1]{\myheading{#1}
+\addcontentsline{toc}{chapter}{#1}}
+
+\newcommand{\sectionheading}[1]{\myheading{#1}
+\addcontentsline{toc}{section}{#1}}
+
+% Glossary environment
+\newenvironment{helpglossary}{\newpage\chapterheading{Glossary}\begin{description}}{\end{description}}
+
+% Glossary entry
+\newcommand{\gloss}[1]{\item[#1]\index{#1}}
+
+% Image: EPS in Latex, BMP or MF (whatever's available) in RTF. Requires psbox.
+\newcommand{\image}[2]{\psboxto(#1){#2}}
+
+% Image, left aligned (HTML)
+\newcommand{\imager}[2]{\psboxto(#1){#2}}
+
+% Image, right aligned (HTML)
+\newcommand{\imagel}[2]{\psboxto(#1){#2}}
+
+% Imagemap: principally for HTML only. In Latex,
+% acts like \image.
+\newcommand{\imagemap}[3]{\psboxto(#1){#2}}
+
+% Headers and footers
+% \setheader{EvenPageLeft}{EvenPageCentre}{EvenPageRight}
+% {OddPageLeft}{OddPageCentre}{OddPageRight}
+\newcommand{\setheader}[6]{
+\lhead[\fancyplain{}{#1}]{\fancyplain{}{#4}}
+\chead[\fancyplain{}{#2}]{\fancyplain{}{#5}}
+\rhead[\fancyplain{}{#3}]{\fancyplain{}{#6}}
+}
+
+% \setfooter{EvenPageLeft}{EvenPageCentre}{EvenPageRight}
+% {OddPageLeft}{OddPageCentre}{OddPageRight}
+\newcommand{\setfooter}[6]{
+\lfoot[\fancyplain{#1}{#1}]{\fancyplain{#4}{#4}}
+\cfoot[\fancyplain{#2}{#2}]{\fancyplain{#5}{#5}}
+\rfoot[\fancyplain{#3}{#3}]{\fancyplain{#6}{#6}}
+}
+
+% Needed for telling RTF where margin paragraph should go
+% in mirrored margins mode.
+\newcommand{\marginpareven}[1]{\hspace*{0pt}\marginpar{#1}}
+\newcommand{\marginparodd}[1]{\hspace*{0pt}\marginpar{#1}}
+
+% Environment for two-column table popular in WinHelp and manuals.
+\newcommand{\twocolwidtha}[1]{\def\twocolwidthaval{#1}}
+\newcommand{\twocolwidthb}[1]{\def\twocolwidthbval{#1}}
+\newcommand{\twocolspacing}[1]{\def\twocolspacingval{#1}}
+
+\twocolwidtha{3cm}
+\twocolwidthb{8.5cm}
+\twocolspacing{2}
+
+\newcommand{\twocolitem}[2]{#1 & #2\\}
+\newcommand{\twocolitemruled}[2]{#1 & #2\\\hline}
+
+\newenvironment{twocollist}{\renewcommand{\arraystretch}{\twocolspacingval}\begin{tabular}{lp{\twocolwidthbval}}}%
+{\end{tabular}\renewcommand{\arraystretch}{1}}
+
+% Specifying table rows for RTF compatibility
+\newcommand{\row}[1]{#1\\}
+
+% Use for the last ruled row for correct RTF generation.
+\newcommand{\ruledrow}[1]{#1\\\hline}
+
+% Indentation environment. Arg1 is left margin size
+\newenvironment{indented}[1]{\begin{list}{}{\leftmargin=#1}\item[]}%
+{\end{list}}
+
+% Framed box of text, normal formatting.
+\newcommand{\normalbox}[1]{\fbox{\vbox{#1}}}
+% Double-framed box of text.
+\newcommand{\normalboxd}[1]{\fbox{\fbox{\vbox{#1}}}}
+
+% WITHDRAWN -- can't do in RTF, easily.
+% Framed box of text, horizontally centred. Ragged right within box.
+% \newcommand{\centeredbox}[2]{\begin{center}\fbox{\parbox{#1}{\raggedright#2}}\end{center}}
+% Double-framed box of text, horizontally centred. Ragged right within box.
+% \newcommand{\centeredboxd}[2]{\begin{center}\fbox{\fbox{\parbox{#1}{\raggedright#2}}}\end{center}}
+
+% toocomplex environment: simply prints the argument in LaTeX,
+% comes out verbatim in all generated formats.
+\newenvironment{toocomplex}{}{}
+
+% Colour: dummy commands since LaTeX doesn't support colour.
+% \definecolour{name}{red}{blue}{green}
+% \fcol{name}{text} ; Foreground
+% \bcol{name}{text} ; Background
+\newcommand{\definecolour}[4]{}
+\newcommand{\definecolor}[4]{}
+\newcommand{\fcol}[2]{#2}
+\newcommand{\bcol}[2]{#2}
+\newcommand{\sethotspotcolour}[1]{}
+\newcommand{\sethotspotunderline}[1]{}
+\newcommand{\settransparency}[1]{}
+\newcommand{\backslashraw}[0]{}
+\newcommand{\lbraceraw}[0]{}
+\newcommand{\rbraceraw}[0]{}
+\newcommand{\registered}[0]{(r)}
+\newcommand{\background}[1]{}
+\newcommand{\textcolour}[1]{}
+\newcommand{\overview}[2]{See \helpref{#1}{#2}.}
+\newcommand{\docparam}[2]{{\it #1}\begin{list}{}{\leftmargin=1cm}\item[]
+#2%
+\end{list}}
+\newcommand{\wxheading}[1]{{\bf #1}}
+\newcommand{\const}[0]{{\bf const}}
+\newcommand{\constfunc}[3]{{\bf #1} {\bf #2}(#3) {\bf const}\index{#2}}
+

docs/latex/porting/up.gif

@@ -0,0 +1 @@
+GIF87a

docs/latex/wx/accel.tex

@@ -0,0 +1,190 @@
+\section{\class{wxAcceleratorEntry}}\label{wxacceleratorentry}
+
+An object used by an application wishing to create an \helpref{accelerator table}{wxacceleratortable}.
+
+\wxheading{Derived from}
+
+None
+
+\wxheading{See also}
+
+\helpref{wxAcceleratorTable}{wxacceleratortable}, \helpref{wxWindow::SetAcceleratorTable}{wxwindowsetacceleratortable}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxAcceleratorEntry::wxAcceleratorEntry}\label{wxacceleratorentryconstr}
+
+\func{}{wxAcceleratorEntry}{\void}
+
+Default constructor.
+
+\func{}{wxAcceleratorEntry}{\param{int}{ flags}, \param{int}{ keyCode}, \param{int}{ cmd}}
+
+Constructor.
+
+\wxheading{Parameters}
+
+\docparam{flags}{One of wxACCEL\_SHIFT, wxACCEL\_CTRL and wxACCEL\_NORMAL. Indicates
+which modifier key is held down.}
+
+\docparam{keyCode}{The keycode to be detected. See \helpref{Keycodes}{keycodes} for a full list of keycodes.}
+
+\docparam{cmd}{The menu or control command identifier.}
+
+\membersection{wxAcceleratorEntry::GetCommand}\label{wxacceleratorentrygetcommand}
+
+\constfunc{int}{GetCommand}{\void}
+
+Returns the command identifier for the accelerator table entry.
+
+\membersection{wxAcceleratorEntry::GetFlags}\label{wxacceleratorentrygetflags}
+
+\constfunc{int}{GetFlags}{\void}
+
+Returns the flags for the accelerator table entry.
+
+\membersection{wxAcceleratorEntry::GetKeyCode}\label{wxacceleratorentrygetkeycode}
+
+\constfunc{int}{GetKeyCode}{\void}
+
+Returns the keycode for the accelerator table entry.
+
+\membersection{wxAcceleratorEntry::Set}\label{wxacceleratorentryset}
+
+\func{void}{Set}{\param{int}{ flags}, \param{int}{ keyCode}, \param{int}{ cmd}}
+
+Sets the accelerator entry parameters.
+
+\wxheading{Parameters}
+
+\docparam{flags}{One of wxACCEL\_SHIFT, wxACCEL\_CTRL and wxACCEL\_NORMAL. Indicates
+which modifier key is held down.}
+
+\docparam{keyCode}{The keycode to be detected. See \helpref{Keycodes}{keycodes} for a full list of keycodes.}
+
+\docparam{cmd}{The menu or control command identifier.}
+
+\section{\class{wxAcceleratorTable}}\label{wxacceleratortable}
+
+An accelerator table allows the application to specify a table of keyboard shortcuts for
+menus or other commands. On Windows, menu or button commands are supported; on GTK,
+only menu commands are supported.
+
+The object {\bf wxNullAcceleratorTable} is defined to be a table with no data, and is the
+initial accelerator table for a window.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Example}
+
+{\small%
+\begin{verbatim}
+  wxAcceleratorEntry entries[4];
+  entries[0].Set(wxACCEL_CTRL,  (int) 'N',     ID_NEW_WINDOW);
+  entries[1].Set(wxACCEL_CTRL,  (int) 'X',     wxID_EXIT);
+  entries[2].Set(wxACCEL_SHIFT, (int) 'A',     ID_ABOUT);
+  entries[3].Set(wxACCEL_NONE,  WXK_DELETE,    wxID_CUT);
+  wxAcceleratorTable accel(4, entries);
+  frame->SetAcceleratorTable(accel);
+\end{verbatim}
+}
+
+\wxheading{Remarks}
+
+An accelerator takes precedence over normal processing and can be a convenient way to program some event handling.
+For example, you can use an accelerator table to enable a dialog with a multi-line text control to
+accept CTRL-Enter as meaning 'OK' (but not in GTK at present).
+
+\wxheading{See also}
+
+\helpref{wxAcceleratorEntry}{wxacceleratorentry}, \helpref{wxWindow::SetAcceleratorTable}{wxwindowsetacceleratortable}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxAcceleratorTable::wxAcceleratorTable}\label{wxacceleratortableconstr}
+
+\func{}{wxAcceleratorTable}{\void}
+
+Default constructor.
+
+\func{}{wxAcceleratorTable}{\param{const wxAcceleratorTable\& }{bitmap}}
+
+Copy constructor.
+
+\func{}{wxAcceleratorTable}{\param{int}{ n}, \param{wxAcceleratorEntry}{ entries[]}}
+
+Creates from an array of \helpref{wxAcceleratorEntry}{wxacceleratorentry} objects.
+
+\func{}{wxAcceleratorTable}{\param{const wxString\&}{ resource}}
+
+Loads the accelerator table from a Windows resource (Windows only).
+
+\wxheading{Parameters}
+
+\docparam{n}{Number of accelerator entries.}
+
+\docparam{entries}{The array of entries.}
+
+\docparam{resource}{Name of a Windows accelerator.}
+
+\membersection{wxAcceleratorTable::\destruct{wxAcceleratorTable}}
+
+\func{}{\destruct{wxAcceleratorTable}}{\void}
+
+Destroys the wxAcceleratorTable object.
+
+\membersection{wxAcceleratorTable::Ok}\label{wxacceleratortableok}
+
+\constfunc{bool}{Ok}{\void}
+
+Returns TRUE if the accelerator table is valid.
+
+\membersection{wxAcceleratorTable::operator $=$}
+
+\func{wxAcceleratorTable\& }{operator $=$}{\param{const wxAcceleratorTable\& }{accel}}
+
+Assignment operator. This operator does not copy any data, but instead
+passes a pointer to the data in {\it accel} and increments a reference
+counter. It is a fast operation.
+
+\wxheading{Parameters}
+
+\docparam{accel}{Accelerator table to assign.}
+
+\wxheading{Return value}
+
+Returns 'this' object.
+
+\membersection{wxAcceleratorTable::operator $==$}
+
+\func{bool}{operator $==$}{\param{const wxAcceleratorTable\& }{accel}}
+
+Equality operator. This operator tests whether the internal data pointers are
+equal (a fast test).
+
+\wxheading{Parameters}
+
+\docparam{accel}{Accelerator table to compare with 'this'}
+
+\wxheading{Return value}
+
+Returns TRUE if the accelerator tables were effectively equal, FALSE otherwise.
+
+\membersection{wxAcceleratorTable::operator $!=$}
+
+\func{bool}{operator $!=$}{\param{const wxAcceleratorTable\& }{accel}}
+
+Inequality operator. This operator tests whether the internal data pointers are
+unequal (a fast test).
+
+\wxheading{Parameters}
+
+\docparam{accel}{Accelerator table to compare with 'this'}
+
+\wxheading{Return value}
+
+Returns TRUE if the accelerator tables were unequal, FALSE otherwise.
+
+

docs/latex/wx/activevt.tex

@@ -0,0 +1,56 @@
+\section{\class{wxActivateEvent}}\label{wxactivateevent}
+
+An activate event is sent when a window or application is being activated
+or deactivated.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+To process an activate event, use these event handler macros to direct input to a member
+function that takes a wxActivateEvent argument.
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_ACTIVATE(func)}}{Process a wxEVT\_ACTIVATE event.}
+\twocolitem{{\bf EVT\_ACTIVATE\_APP(func)}}{Process a wxEVT\_ACTIVATE\_APP event.}
+\end{twocollist}%
+
+\wxheading{Remarks}
+
+A top-level window (a dialog or frame) receives an activate event when is
+being activated or deactivated. This is indicated visually by the title
+bar changing colour, and a subwindow gaining the keyboard focus.
+
+An application is activated or deactivated when one of its frames becomes activated,
+or a frame becomes inactivate resulting in all application frames being inactive. (Windows only)
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnActivate}{wxwindowonactivate},\rtfsp
+\helpref{wxApp::OnActivate}{wxapponactivate},\rtfsp
+\helpref{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxActivateEvent::wxActivateEvent}
+
+\func{}{wxActivateEvent}{\param{WXTYPE }{eventType = 0}, \param{bool}{ active = TRUE}, \param{int }{id = 0}}
+
+Constructor.
+
+\membersection{wxActivateEvent::m\_active}
+
+\member{bool}{m\_active}
+
+TRUE if the window or application was activated.
+
+\membersection{wxActivateEvent::GetActive}\label{wxactivateeventgetactive}
+
+\constfunc{bool}{GetActive}{\void}
+
+Returns TRUE if the application or window is being activated, FALSE otherwise.
+

docs/latex/wx/app.tex

@@ -0,0 +1,459 @@
+\section{\class{wxApp}}\label{wxapp}
+
+The {\bf wxApp} class represents the application itself. It is used
+to:
+
+\begin{itemize}\itemsep=0pt
+\item set and get application-wide properties;
+\item implement the windowing system message or event loop;
+\item initiate application processing via \helpref{wxApp::OnInit}{wxapponinit};
+\item allow default processing of events not handled by other
+objects in the application.
+\end{itemize}
+
+You should use the macro IMPLEMENT\_APP(appClass) in your application implementation
+file to tell wxWindows how to create an instance of your application class.
+
+Use DECLARE\_APP(appClass) in a header file if you want the wxGetApp function (which returns
+a reference to your application object) to be visible to other files.
+
+\wxheading{Derived from}
+
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxApp overview}{wxappoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxApp::wxApp}
+
+\func{void}{wxApp}{\param{int}{ language = wxLANGUAGE\_ENGLISH}}
+
+Constructor. Called implicitly with a definition of a wxApp object.
+
+The argument is a language identifier; this is an experimental
+feature and will be expanded and documented in future versions.
+
+TODO: completely rewrite the language stuff.
+
+\membersection{wxApp::\destruct{wxApp}}
+
+\func{void}{\destruct{wxApp}}{\void}
+
+Destructor. Will be called implicitly on program exit if the wxApp
+object is created on the stack.
+
+\membersection{wxApp::argc}\label{wxappargc}
+
+\member{int}{argc}
+
+Number of command line arguments (after environment-specific processing).
+
+\membersection{wxApp::argv}\label{wxappargv}
+
+\member{char **}{argv}
+
+Command line arguments (after environment-specific processing).
+
+\membersection{wxApp::CreateLogTarget}\label{wxappcreatelogtarget}
+
+\func{virtual wxLog*}{CreateLogTarget}{\void}
+
+Creates a wxLog class for the application to use for logging errors. The default
+implementation returns a new wxLogGui class.
+
+\wxheading{See also}
+
+\helpref{wxLog}{wxlog}
+
+\membersection{wxApp::Dispatch}\label{wxappdispatch}
+
+\func{void}{Dispatch}{\void}
+
+Dispatches the next event in the windowing system event queue.
+
+This can be used for programming event loops, e.g.
+
+\begin{verbatim}
+  while (app.Pending())
+    Dispatch();
+\end{verbatim}
+
+\wxheading{See also}
+
+\helpref{wxApp::Pending}{wxapppending}
+
+\membersection{wxApp::GetAppName}\label{wxappgetappname}
+
+\constfunc{wxString}{GetAppName}{\void}
+
+Returns the application name.
+
+\wxheading{Remarks}
+
+wxWindows sets this to a reasonable default before
+calling \helpref{wxApp::OnInit}{wxapponinit}, but the application can reset it at will.
+
+\membersection{wxApp::GetAuto3D}\label{wxappgetauto3d}
+
+\constfunc{bool}{GetAuto3D}{\void}
+
+Returns TRUE if 3D control mode is on, FALSE otherwise.
+
+\wxheading{See also}
+
+\helpref{wxApp::SetAuto3D}{wxappsetauto3d}
+
+\membersection{wxApp::GetClassName}\label{wxappgetclassname}
+
+\constfunc{wxString}{GetClassName}{\void}
+
+Gets the class name of the application. The class name may be used in a platform specific
+manner to refer to the application.
+
+\wxheading{See also}
+
+\helpref{wxApp::SetClassName}{wxappsetclassname}
+
+\membersection{wxApp::GetExitOnDelete}\label{wxappgetexitondelete}
+
+\constfunc{bool}{GetExitOnDelete}{\void}
+
+Returns TRUE if the application will exit when the top-level window is deleted, FALSE
+otherwise.
+
+\wxheading{See also}
+
+\helpref{wxApp::SetExitOnDelete}{wxappsetexitondelete}
+
+\membersection{wxApp::GetPrintMode}\label{wxappgetprintmode}
+
+\constfunc{bool}{GetPrintMode}{\void}
+
+Returns the print mode: see \helpref{wxApp::SetPrintMode}{wxappsetprintmode}.
+
+\membersection{wxApp::GetTopWindow}\label{wxappgettopwindow}
+
+\constfunc{wxWindow *}{GetTopWindow}{\void}
+
+Returns a pointer to the top window.
+
+\wxheading{See also}
+
+\helpref{wxApp::SetTopWindow}{wxappsettopwindow}
+
+\membersection{wxApp::ExitMainLoop}\label{wxappexitmainloop}
+
+\func{void}{ExitMainLoop}{\void}
+
+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.
+
+\membersection{wxApp::Initialized}\label{wxappinitialized}
+
+\func{bool}{Initialized}{\void}
+
+Returns TRUE if the application has been initialized (i.e. if\rtfsp
+\helpref{wxApp::OnInit}{wxapponinit} 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).
+
+\membersection{wxApp::MainLoop}\label{wxappmainloop}
+
+\func{int}{MainLoop}{\void}
+
+Called by wxWindows on creation of the application. Override this if you wish
+to provide your own (environment-dependent) main loop.
+
+\wxheading{Return value}
+
+Returns 0 under X, and the wParam of the WM\_QUIT message under Windows.
+
+\membersection{wxApp::OnActivate}\label{wxapponactivate}
+
+\func{void}{OnActivate}{\param{wxActivateEvent\& }{event}}
+
+Provide this member function to know whether the application is being
+activated or deactivated (Windows only).
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnActivate}{wxwindowonactivate}, \helpref{wxActivateEvent}{wxactivateevent}
+
+\membersection{wxApp::OnExit}\label{wxapponexit}
+
+\func{int}{OnExit}{\void}
+
+Provide this member function for any processing which needs to be done as
+the application is about to exit.
+
+\membersection{wxApp::OnCharHook}\label{wxapponcharhook}
+
+\func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
+
+This event handler function is called (under Windows only) to allow the window to intercept keyboard events
+before they are processed by child windows.
+
+\wxheading{Parameters}
+
+\docparam{event}{The keypress event.}
+
+\wxheading{Remarks}
+
+Use the wxEVT\_CHAR\_HOOK macro in your event table.
+
+If you use this member, you can selectively consume keypress events by calling\rtfsp
+\helpref{wxEvent::Skip}{wxeventskip} for characters the application is not interested in.
+
+\wxheading{See also}
+
+\helpref{wxKeyEvent}{wxkeyevent}, \helpref{wxWindow::OnChar}{wxwindowonchar},\rtfsp
+\helpref{wxWindow::OnCharHook}{wxwindowoncharhook}, \helpref{wxDialog::OnCharHook}{wxdialogoncharhook}
+
+\membersection{wxApp::OnIdle}\label{wxapponidle}
+
+\func{void}{OnIdle}{\param{wxIdleEvent\& }{event}}
+
+Override this member function for any processing which needs to be done
+when the application is idle. You should call wxApp::OnIdle from your own function,
+since this forwards OnIdle events to windows and also performs garbage collection for
+windows whose destruction has been delayed.
+
+wxWindows' strategy for OnIdle processing is as follows. After pending user interface events for an
+application have all been processed, wxWindows sends an OnIdle event to the application object. wxApp::OnIdle itself
+sends an OnIdle event to each application window, allowing windows to do idle processing such as updating
+their appearance. If either wxApp::OnIdle or a window OnIdle function requested more time, by
+caling \helpref{wxIdleEvent::ReqestMore}{wxidleeventrequestmore}, wxWindows will send another OnIdle
+event to the application event. This will occur in a loop until either a user event is found to be
+pending, or OnIdle requests no more time. Then all pending user events are processed until the system
+goes idle again, when OnIdle is called, and so on.
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnIdle}{wxwindowonidle}, \helpref{wxIdleEvent}{wxidleevent},\rtfsp
+\helpref{wxWindow::SendIdleEvents}{wxappsendidleevents}
+
+\membersection{wxApp::OnEndSession}\label{wxapponendsession}
+
+\func{void}{OnEndSession}{\param{wxCloseEvent\& }{event}}
+
+This is an event handler function called when the operating system or GUI session is
+about to close down. The application has a chance to silently save information,
+and can optionally close itself.
+
+Use the EVT\_END\_SESSION event table macro to handle query end session events.
+
+The default handler calls \helpref{wxWindow::Close}{wxwindowclose} with a TRUE argument
+(forcing the application to close itself silently).
+
+\wxheading{Remarks}
+
+Under X, OnEndSession is called in response to the 'die' event.
+
+Under Windows, OnEndSession is called in response to the WM\_ENDSESSION message.
+
+\wxheading{See also}
+
+\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
+\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
+\helpref{wxCloseEvent}{wxcloseevent},\rtfsp
+\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession}
+
+\membersection{wxApp::OnInit}\label{wxapponinit}
+
+\func{bool}{OnInit}{\void}
+
+This must be provided by the application, and will usually create the
+application's main window, calling \helpref{wxApp::SetTopWindow}{wxappsettopwindow}.
+
+Return TRUE to continue processing, FALSE to exit the application.
+
+\membersection{wxApp::OnQueryEndSession}\label{wxapponqueryendsession}
+
+\func{void}{OnQueryEndSession}{\param{wxCloseEvent\& }{event}}
+
+This is an event handler function called when the operating system or GUI session is
+about to close down. Typically, an application will try to save unsaved documents
+at this point.
+
+If \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto} returns TRUE, the application
+is allowed to veto the shutdown by calling \helpref{wxCloseEvent::Veto}{wxcloseeventveto}.
+The application might veto the shutdown after prompting for documents to be saved, and the
+user has cancelled the save.
+
+Use the EVT\_QUERY\_END\_SESSION event table macro to handle query end session events.
+
+You should check whether the application is forcing the deletion of the window
+using \helpref{wxCloseEvent::GetForce}{wxcloseeventgetforce}. If this is TRUE,
+destroy the window using \helpref{wxWindow::Destroy}{wxwindowdestroy}.
+If not, it is up to you whether you respond by destroying the window.
+
+The default handler calls \helpref{wxWindow::Close}{wxwindowclose} on the top-level window,
+and vetoes the shutdown if Close returns FALSE. This will be sufficient for many applications.
+
+\wxheading{Remarks}
+
+Under X, OnQueryEndSession is called in response to the 'save session' event.
+
+Under Windows, OnQueryEndSession is called in response to the WM\_QUERYENDSESSION message.
+
+\wxheading{See also}
+
+\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
+\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
+\helpref{wxCloseEvent}{wxcloseevent},\rtfsp
+\helpref{wxApp::OnEndSession}{wxapponendsession}
+
+\membersection{wxWindow::OnScroll}\label{wxwindowonscroll}
+
+\membersection{wxApp::ProcessMessage}\label{wxappprocessmessage}
+
+\func{bool}{ProcessMessage}{\param{MSG *}{msg}}
+
+Windows-only function for processing a message. This function
+is called from the main message loop, checking for windows that
+may wish to process it. The function returns TRUE if the message
+was processed, FALSE otherwise. If you use wxWindows with another class
+library with its own message loop, you should make sure that this
+function is called to allow wxWindows to receive messages. For example,
+to allow co-existance with the Microsoft Foundation Classes, override
+the PreTranslateMessage function:
+
+\begin{verbatim}
+// Provide wxWindows message loop compatibility
+BOOL CTheApp::PreTranslateMessage(MSG *msg)
+{
+  if (wxTheApp && wxTheApp->ProcessMessage(msg))
+    return TRUE;
+  else
+    return CWinApp::PreTranslateMessage(msg);
+}
+\end{verbatim}
+
+\membersection{wxApp::Pending}\label{wxapppending}
+
+\func{bool}{Pending}{\void}
+
+Returns TRUE if unprocessed events are in the window system event queue
+(MS Windows and Motif).
+
+\wxheading{See also}
+
+\helpref{wxApp::Dispatch}{wxappdispatch}
+
+\membersection{wxApp::SendIdleEvents}\label{wxappsendidleevents}
+
+\func{bool}{SendIdleEvents}{\void}
+
+Sends idle events to all top-level windows.
+
+\func{bool}{SendIdleEvents}{\param{wxWindow*}{ win}}
+
+Sends idle events to a window and its children.
+
+\wxheading{Remarks}
+
+These functions poll the top-level windows, and their children, for idle event processing.
+If TRUE is returned, more OnIdle processing is requested by one or more window.
+
+\wxheading{See also}
+
+\helpref{wxApp::OnIdle}{wxapponidle}, \helpref{wxWindow::OnIdle}{wxwindowonidle}, \helpref{wxIdleEvent}{wxidleevent}
+
+\membersection{wxApp::SetAppName}\label{wxappsetappname}
+
+\func{void}{SetAppName}{\param{const wxString\& }{name}}
+
+Sets the name of the application. The name may be used in dialogs
+(for example by the document/view framework). A default name is set by
+wxWindows.
+
+\wxheading{See also}
+
+\helpref{wxApp::GetAppName}{wxappgetappname}
+
+\membersection{wxApp::SetAuto3D}\label{wxappsetauto3d}
+
+\func{void}{SetAuto3D}{\param{const bool}{ auto3D}}
+
+Switches automatic 3D controls on or off.
+
+\wxheading{Parameters}
+
+\docparam{auto3D}{If TRUE, all controls will be created with 3D appearances unless
+overridden for a control or dialog. The default is TRUE}
+
+\wxheading{Remarks}
+
+This has an effect on Windows only.
+
+\wxheading{See also}
+
+\helpref{wxApp::GetAuto3D}{wxappgetauto3d}
+
+\membersection{wxApp::SetClassName}\label{wxappsetclassname}
+
+\func{void}{SetClassName}{\param{const wxString\& }{name}}
+
+Sets the class name of the application. This may be used in a platform specific
+manner to refer to the application.
+
+\wxheading{See also}
+
+\helpref{wxApp::GetClassName}{wxappgetclassname}
+
+\membersection{wxApp::SetExitOnDelete}\label{wxappsetexitondelete}
+
+\func{void}{SetExitOnDelete}{\param{bool}{ flag}}
+
+Allows the programmer to specify whether the application will exit when the
+top-level frame is deleted.
+
+\wxheading{Parameters}
+
+\docparam{flag}{If TRUE (the default), the application will exit when the top-level frame is
+deleted. If FALSE, the application will continue to run.}
+
+\wxheading{Remarks}
+
+Currently, setting this to FALSE only has an effect under Windows.
+
+\membersection{wxApp::SetPrintMode}\label{wxappsetprintmode}
+
+\func{void}{SetPrintMode}{\param{int}{ mode}}
+
+Sets the print mode determining what printing facilities will be
+used by the printing framework.
+
+\wxheading{Parameters}
+
+\docparam{mode}{This can be one of:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxPRINT\_WINDOWS}}{Under Windows, use Windows printing (wxPrinterDC). This is the
+default under Windows.}
+\twocolitem{{\bf wxPRINT\_POSTSCRIPT}}{Use PostScript printing (wxPostScriptDC). This is the
+default for non-Windows platforms.}
+\end{twocollist}
+}%
+
+\membersection{wxApp::SetTopWindow}\label{wxappsettopwindow}
+
+\func{void}{SetTopWindow}{\param{wxWindow* }{window}}
+
+Sets the `top' window. You should normally call this from within \helpref{wxApp::OnInit}{wxapponinit} to
+let wxWindows know which is the main window.
+
+\wxheading{Parameters}
+
+\docparam{window}{The new top window.}
+
+\wxheading{See also}
+
+\helpref{wxApp::GetTopWindow}{wxappgettopwindow}, \helpref{wxApp::OnInit}{wxapponinit}
+

docs/latex/wx/bbutton.tex

@@ -0,0 +1,231 @@
+\section{\class{wxBitmapButton}}\label{wxbitmapbutton}
+
+A bitmap button is a control that contains a bitmap.
+It may be placed on a \helpref{dialog box}{wxdialog} or \helpref{panel}{wxpanel}, or indeed
+almost any other window.
+
+\wxheading{Derived from}
+
+\helpref{wxButton}{wxbutton}\\
+\helpref{wxControl}{wxcontrol}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Remarks}
+
+A bitmap button can be supplied with a single bitmap, and wxWindows will draw
+all button states using this bitmap. If the application needs more control, additional bitmaps for
+the selected state, unpressed focussed state, and greyed-out state may be supplied.
+
+\wxheading{Window styles}
+
+\twocolwidtha{5cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxBU\_AUTODRAW}}{If
+this is specified, the button will be drawn automatically using the label bitmap only, providing
+a 3D-look border. If this style is not specified, the button will be drawn without borders and using all
+provided bitmaps.}
+\end{twocollist}
+
+See also \helpref{window styles overview}{windowstyles}.
+
+\wxheading{Event handling}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_BUTTON(id, func)}}{Process a wxEVT\_COMMAND\_BUTTON\_CLICKED event,
+when the button is clicked.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxButton}{wxbutton}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxBitmapButton::wxBitmapButton}\label{wxbitmapbuttonconstr}
+
+\func{}{wxBitmapButton}{\void}
+
+Default constructor.
+
+\func{}{wxBitmapButton}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id}, \param{const wxBitmap\& }{bitmap},\rtfsp
+\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = wxBU\_AUTODRAW}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
+
+Constructor, creating and showing a button.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window. Must not be NULL.}
+
+\docparam{id}{Button identifier. A value of -1 indicates a default value.}
+
+\docparam{bitmap}{Bitmap to be displayed.}
+
+\docparam{pos}{Button position.}
+
+\docparam{size}{Button size. If the default size (-1, -1) is specified then the button is sized
+appropriately for the bitmap.}
+
+\docparam{style}{Window style. See \helpref{wxBitmapButton}{wxbitmapbutton}.}
+
+\docparam{validator}{Window validator.}
+
+\docparam{name}{Window name.}
+
+\wxheading{Remarks}
+
+The {\it bitmap} parameter is normally the only bitmap you need to provide, and wxWindows will
+draw the button correctly in its different states. If you want more control, call
+any of the functions \helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected},\rtfsp
+\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus},\rtfsp
+\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}.
+
+Note that the bitmap passed is smaller than the actual button created.
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::Create}{wxbitmapbuttoncreate}, \helpref{wxValidator}{wxvalidator}
+
+\membersection{wxBitmapButton::\destruct{wxBitmapButton}}
+
+\func{}{\destruct{wxBitmapButton}}{\void}
+
+Destructor, destroying the button.
+
+\membersection{wxBitmapButton::Create}\label{wxbitmapbuttoncreate}
+
+\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id}, \param{const wxBitmap\& }{bitmap},\rtfsp
+\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
+
+Button creation function for two-step creation. For more details, see \helpref{wxBitmapButton::wxBitmapButton}{wxbitmapbuttonconstr}.
+
+\membersection{wxBitmapButton::GetBitmapDisabled}\label{wxbitmapbuttongetbitmapdisabled}
+
+\constfunc{wxBitmap\&}{GetBitmapLabel}{\void}
+
+Returns the bitmap for the disabled state.
+
+\wxheading{Return value}
+
+A reference to the disabled state bitmap.
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}
+
+\membersection{wxBitmapButton::GetBitmapFocus}\label{wxbitmapbuttongetbitmapfocus}
+
+\constfunc{wxBitmap\&}{GetBitmapFocus}{\void}
+
+Returns the bitmap for the focussed state.
+
+\wxheading{Return value}
+
+A reference to the focussed state bitmap.
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus}
+
+\membersection{wxBitmapButton::GetBitmapLabel}\label{wxbitmapbuttongetbitmaplabel}
+
+\constfunc{wxBitmap\&}{GetBitmapLabel}{\void}
+
+Returns the label bitmap (the one passed to the constructor).
+
+\wxheading{Return value}
+
+A reference to the button's label bitmap.
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel}
+
+\membersection{wxBitmapButton::GetBitmapSelected}\label{wxbitmapbuttongetbitmapselected}
+
+\constfunc{wxBitmap\&}{GetBitmapSelected}{\void}
+
+Returns the bitmap for the selected state.
+
+\wxheading{Return value}
+
+A reference to the selected state bitmap.
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected}
+
+\membersection{wxBitmapButton::SetBitmapDisabled}\label{wxbitmapbuttonsetbitmapdisabled}
+
+\func{void}{SetBitmapDisabled}{\param{const wxBitmap\& }{bitmap}}
+
+Sets the bitmap for the disabled button appearance.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The bitmap to set.}
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::GetBitmapDisabled}{wxbitmapbuttongetbitmapdisabled},\rtfsp
+\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel},\rtfsp
+\helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected},\rtfsp
+\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus}
+
+\membersection{wxBitmapButton::SetBitmapFocus}\label{wxbitmapbuttonsetbitmapfocus}
+
+\func{void}{SetBitmapFocus}{\param{const wxBitmap\& }{bitmap}}
+
+Sets the bitmap for the button appearance when it has the keyboard focus.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The bitmap to set.}
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::GetBitmapFocus}{wxbitmapbuttongetbitmapfocus},\rtfsp
+\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel},\rtfsp
+\helpref{wxBitmapButton::SetBitmapSelected}{wxbitmapbuttonsetbitmapselected},\rtfsp
+\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}
+
+\membersection{wxBitmapButton::SetBitmapLabel}\label{wxbitmapbuttonsetbitmaplabel}
+
+\func{void}{SetBitmapLabel}{\param{const wxBitmap\& }{bitmap}}
+
+Sets the bitmap label for the button.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The bitmap label to set.}
+
+\wxheading{Remarks}
+
+This is the bitmap used for the unselected state, and for all other states
+if no other bitmaps are provided.
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::GetBitmapLabel}{wxbitmapbuttongetbitmaplabel}
+
+\membersection{wxBitmapButton::SetBitmapSelected}\label{wxbitmapbuttonsetbitmapselected}
+
+\func{void}{SetBitmapSelected}{\param{const wxBitmap\& }{bitmap}}
+
+Sets the bitmap for the selected (depressed) button appearance.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The bitmap to set.}
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton::GetBitmapSelected}{wxbitmapbuttongetbitmapselected},\rtfsp
+\helpref{wxBitmapButton::SetBitmapLabel}{wxbitmapbuttonsetbitmaplabel},\rtfsp
+\helpref{wxBitmapButton::SetBitmapFocus}{wxbitmapbuttonsetbitmapfocus},\rtfsp
+\helpref{wxBitmapButton::SetBitmapDisabled}{wxbitmapbuttonsetbitmapdisabled}
+

docs/latex/wx/bitmap.tex

@@ -0,0 +1,683 @@
+\section{\class{wxBitmap}}\label{wxbitmap}
+
+%\overview{Overview}{wxbitmapoverview}
+%
+This class encapsulates the concept of a platform-dependent bitmap,
+either monochrome or colour.
+
+\wxheading{Derived from}
+
+\helpref{wxGDIObject}{wxgdiobject}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxBitmap overview}{wxbitmapoverview}, \helpref{wxDC::Blit}{wxdcblit}, \helpref{wxIcon}{wxicon}, \helpref{wxCursor}{wxcursor}, \helpref{wxMemoryDC}{wxmemorydc}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxBitmap::wxBitmap}\label{wxbitmapconstr}
+
+\func{}{wxBitmap}{\void}
+
+Default constructor.
+
+\func{}{wxBitmap}{\param{const wxBitmap\& }{bitmap}}
+
+\func{}{wxBitmap}{\param{const wxBitmap* }{bitmap}}
+
+Copy constructors.
+
+\func{}{wxBitmap}{\param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
+
+Creates a bitmap from the given data, which can be of arbitrary type.
+
+\func{}{wxBitmap}{\param{const char}{ bits[]}, \param{int}{ width}, \param{int}{ height}\\
+  \param{int}{ depth = 1}}
+
+Creates a bitmap from an array of bits.
+
+\func{}{wxBitmap}{\param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
+
+Creates a new bitmap.
+
+\func{}{wxBitmap}{\param{const char**}{ bits}}
+
+Creates a bitmap from XPM data.
+
+\func{}{wxBitmap}{\param{const wxString\& }{name}, \param{long}{ type}}
+
+Loads a bitmap from a file or resource.
+
+\wxheading{Parameters}
+
+\docparam{bits}{Specifies an array of pixel values.}
+
+\docparam{width}{Specifies the width of the bitmap.}
+
+\docparam{height}{Specifies the height of the bitmap.}
+
+\docparam{depth}{Specifies the depth of the bitmap. If this is omitted, the display depth of the
+screen is used.}
+
+\docparam{name}{This can refer to a resource name under MS Windows, or a filename under MS Windows and X.
+Its meaning is determined by the {\it flags} parameter.}
+
+\docparam{type}{May be one of the following:
+
+\twocolwidtha{5cm}
+\begin{twocollist}
+\twocolitem{{\bf \indexit{wxBITMAP\_TYPE\_BMP}}}{Load a Windows bitmap file.}
+\twocolitem{{\bf \indexit{wxBITMAP\_TYPE\_BMP\_RESOURCE}}}{Load a Windows bitmap from the resource database.}
+\twocolitem{{\bf \indexit{wxBITMAP\_TYPE\_GIF}}}{Load a GIF bitmap file.}
+\twocolitem{{\bf \indexit{wxBITMAP\_TYPE\_XBM}}}{Load an X bitmap file.}
+\twocolitem{{\bf \indexit{wxBITMAP\_TYPE\_XPM}}}{Load an XPM bitmap file.}
+\twocolitem{{\bf \indexit{wxBITMAP\_TYPE\_RESOURCE}}}{Load a Windows resource name.}
+\end{twocollist}
+
+The validity of these flags depends on the platform and wxWindows configuration.
+If all possible wxWindows settings are used, the Windows platform supports BMP, BMP\_RESOURCE,
+XPM\_DATA, and XPM. Under X, the available formats are BMP, GIF, XBM, and XPM.}
+
+\wxheading{Remarks}
+
+The first form constructs a bitmap object with no data; an assignment or another member function such as Create
+or LoadFile must be called subsequently.
+
+The second and third forms provide copy constructors. Note that these do not copy the
+bitmap data, but instead a pointer to the data, keeping a reference count. They are therefore
+very efficient operations.
+
+The fourth form constructs a bitmap from data whose type and value depends on
+the value of the {\it type} argument.
+
+The fifth form constructs a (usually monochrome) bitmap from an array of pixel values, under both
+X and Windows.
+
+The sixth form constructs a new bitmap.
+
+The seventh form constructs a bitmap from pixmap (XPM) data, if wxWindows has been configured
+to incorporate this feature.
+
+To use this constructor, you must first include an XPM file. For
+example, assuming that the file {\tt mybitmap.xpm} contains an XPM array
+of character pointers called mybitmap:
+
+\begin{verbatim}
+#include "mybitmap.xpm"
+
+...
+
+wxBitmap *bitmap = new wxBitmap(mybitmap);
+\end{verbatim}
+
+The eighth form constructs a bitmap from a file or resource. {\it name} can refer
+to a resource name under MS Windows, or a filename under MS Windows and X.
+
+Under Windows, {\it type} defaults to wxBITMAP\_TYPE\_BMP\_RESOURCE.
+Under X, {\it type} defaults to wxBITMAP\_TYPE\_XBM.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}
+
+\membersection{wxBitmap::\destruct{wxBitmap}}
+
+\func{}{\destruct{wxBitmap}}{\void}
+
+Destroys the wxBitmap object and possibly the underlying bitmap data.
+Because reference counting is used, the bitmap may not actually be
+destroyed at this point - only when the reference count is zero will the
+data be deleted.
+
+If the application omits to delete the bitmap explicitly, the bitmap will be
+destroyed automatically by wxWindows when the application exits.
+
+Do not delete a bitmap that is selected into a memory device context.
+
+\membersection{wxBitmap::AddHandler}\label{wxbitmapaddhandler}
+
+\func{static void}{AddHandler}{\param{wxBitmapHandler*}{ handler}}
+
+Adds a handler to the end of the static list of format handlers.
+
+\docparam{handler}{A new bitmap format handler object. There is usually only one instance
+of a given handler class in an application session.}
+
+\wxheading{See also}
+
+\helpref{wxBitmapHandler}{wxbitmaphandler}
+
+\membersection{wxBitmap::CleanUpHandlers}
+
+\func{static void}{CleanUpHandlers}{\void}
+
+Deletes all bitmap handlers.
+
+This function is called by wxWindows on exit.
+
+\membersection{wxBitmap::Create}
+
+\func{virtual bool}{Create}{\param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
+
+Creates a fresh bitmap. If the final argument is omitted, the display depth of
+the screen is used.
+
+\func{virtual bool}{Create}{\param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
+
+Creates a bitmap from the given data, which can be of arbitrary type.
+
+\wxheading{Parameters}
+
+\docparam{width}{The width of the bitmap in pixels.}
+
+\docparam{height}{The height of the bitmap in pixels.}
+
+\docparam{depth}{The depth of the bitmap in pixels. If this is -1, the screen depth is used.}
+
+\docparam{data}{Data whose type depends on the value of {\it type}.}
+
+\docparam{type}{A bitmap type identifier - see \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for a list
+of possible values.}
+
+\wxheading{Return value}
+
+TRUE if the call succeeded, FALSE otherwise.
+
+\wxheading{Remarks}
+
+The first form works on all platforms. The portability of the second form depends on the
+type of data.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::wxBitmap}{wxbitmapconstr}
+
+\membersection{wxBitmap::FindHandler}
+
+\func{static wxBitmapHandler*}{FindHandler}{\param{const wxString\& }{name}}
+
+Finds the handler with the given name.
+
+\func{static wxBitmapHandler*}{FindHandler}{\param{const wxString\& }{extension}, \param{long}{ bitmapType}}
+
+Finds the handler associated with the given extension and type.
+
+\func{static wxBitmapHandler*}{FindHandler}{\param{long }{bitmapType}}
+
+Finds the handler associated with the given bitmap type.
+
+\docparam{name}{The handler name.}
+
+\docparam{extension}{The file extension, such as ``bmp".}
+
+\docparam{bitmapType}{The bitmap type, such as wxBITMAP\_TYPE\_BMP.}
+
+\wxheading{Return value}
+
+A pointer to the handler if found, NULL otherwise.
+
+\wxheading{See also}
+
+\helpref{wxBitmapHandler}{wxbitmaphandler}
+
+\membersection{wxBitmap::GetDepth}
+
+\constfunc{int}{GetDepth}{\void}
+
+Gets the colour depth of the bitmap. A value of 1 indicates a
+monochrome bitmap.
+
+\membersection{wxBitmap::GetHandlers}
+
+\func{static wxList\&}{GetHandlers}{\void}
+
+Returns the static list of bitmap format handlers.
+
+\wxheading{See also}
+
+\helpref{wxBitmapHandler}{wxbitmaphandler}
+
+\membersection{wxBitmap::GetHeight}\label{wxbitmapgetheight}
+
+\constfunc{int}{GetHeight}{\void}
+
+Gets the height of the bitmap in pixels.
+
+\membersection{wxBitmap::GetPalette}\label{wxbitmapgetpalette}
+
+\constfunc{wxPalette*}{GetPalette}{\void}
+
+Gets the associated palette (if any) which may have been loaded from a file
+or set for the bitmap.
+
+\wxheading{See also}
+
+\helpref{wxPalette}{wxpalette}
+
+\membersection{wxBitmap::GetMask}\label{wxbitmapgetmask}
+
+\constfunc{wxMask*}{GetMask}{\void}
+
+Gets the associated mask if any) which may have been loaded from a file
+or set for the bitmap.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::SetMask}{wxbitmapsetmask}, \helpref{wxMask}{wxmask}
+
+\membersection{wxBitmap::GetWidth}\label{wxbitmapgetwidth}
+
+\constfunc{int}{GetWidth}{\void}
+
+Gets the width of the bitmap in pixels.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::GetHeight}{wxbitmapgetheight}
+
+\membersection{wxBitmap::InitStandardHandlers}
+
+\func{static void}{InitStandardHandlers}{\void}
+
+Adds the standard bitmap format handlers, which, depending on wxWindows
+configuration, can be handlers for Windows bitmap, Windows bitmap resource, and XPM.
+
+This function is called by wxWindows on startup.
+
+\wxheading{See also}
+
+\helpref{wxBitmapHandler}{wxbitmaphandler}
+
+\membersection{wxBitmap::InsertHandler}
+
+\func{static void}{InsertHandler}{\param{wxBitmapHandler*}{ handler}}
+
+Adds a handler at the start of the static list of format handlers.
+
+\docparam{handler}{A new bitmap format handler object. There is usually only one instance
+of a given handler class in an application session.}
+
+\wxheading{See also}
+
+\helpref{wxBitmapHandler}{wxbitmaphandler}
+
+\membersection{wxBitmap::LoadFile}\label{wxbitmaploadfile}
+
+\func{bool}{LoadFile}{\param{const wxString\&}{ name}, \param{long}{ type}}
+
+Loads a bitmap from a file or resource.
+
+\wxheading{Parameters}
+
+\docparam{name}{Either a filename or a Windows resource name.
+The meaning of {\it name} is determined by the {\it type} parameter.}
+
+\docparam{type}{One of the following values:
+
+\twocolwidtha{5cm}
+\begin{twocollist}
+\twocolitem{{\bf wxBITMAP\_TYPE\_BMP}}{Load a Windows bitmap file.}
+\twocolitem{{\bf wxBITMAP\_TYPE\_BMP\_RESOURCE}}{Load a Windows bitmap from the resource database.}
+\twocolitem{{\bf wxBITMAP\_TYPE\_GIF}}{Load a GIF bitmap file.}
+\twocolitem{{\bf wxBITMAP\_TYPE\_XBM}}{Load an X bitmap file.}
+\twocolitem{{\bf wxBITMAP\_TYPE\_XPM}}{Load an XPM bitmap file.}
+\end{twocollist}
+
+The validity of these flags depends on the platform and wxWindows configuration.}
+
+\wxheading{Return value}
+
+TRUE if the operation succeeded, FALSE otherwise.
+
+\wxheading{Remarks}
+
+A palette may be associated with the bitmap if one exists (especially for
+colour Windows bitmaps), and if the code supports it. You can check
+if one has been created by using the \helpref{GetPalette}{wxbitmapgetpalette} member.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}
+
+\membersection{wxBitmap::Ok}\label{wxbitmapok}
+
+\constfunc{bool}{Ok}{\void}
+
+Returns TRUE if bitmap data is present.
+
+\membersection{wxBitmap::RemoveHandler}
+
+\func{static bool}{RemoveHandler}{\param{const wxString\& }{name}}
+
+Finds the handler with the given name, and removes it. The handler
+is not deleted.
+
+\docparam{name}{The handler name.}
+
+\wxheading{Return value}
+
+TRUE if the handler was found and removed, FALSE otherwise.
+
+\wxheading{See also}
+
+\helpref{wxBitmapHandler}{wxbitmaphandler}
+
+\membersection{wxBitmap::SaveFile}\label{wxbitmapsavefile}
+
+\func{bool}{SaveFile}{\param{const wxString\& }{name}, \param{int}{ type}, \param{wxPalette* }{palette = NULL}}
+
+Saves a bitmap in the named file.
+
+\wxheading{Parameters}
+
+\docparam{name}{A filename. The meaning of {\it name} is determined by the {\it type} parameter.}
+
+\docparam{type}{One of the following values:
+
+\twocolwidtha{5cm}
+\begin{twocollist}
+\twocolitem{{\bf wxBITMAP\_TYPE\_BMP}}{Save a Windows bitmap file.}
+\twocolitem{{\bf wxBITMAP\_TYPE\_GIF}}{Save a GIF bitmap file.}
+\twocolitem{{\bf wxBITMAP\_TYPE\_XBM}}{Save an X bitmap file.}
+\twocolitem{{\bf wxBITMAP\_TYPE\_XPM}}{Save an XPM bitmap file.}
+\end{twocollist}
+
+The validity of these flags depends on the platform and wxWindows configuration.}
+
+\docparam{palette}{An optional palette used for saving the bitmap. TODO: this parameter should
+probably be eliminated; instead the app should set the palette before saving.}
+
+\wxheading{Return value}
+
+TRUE if the operation succeeded, FALSE otherwise.
+
+\wxheading{Remarks}
+
+Depending on how wxWindows has been configured, not all formats may be available.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}
+
+\membersection{wxBitmap::SetDepth}\label{wxbitmapsetdepth}
+
+\func{void}{SetDepth}{\param{int }{depth}}
+
+Sets the depth member (does not affect the bitmap data).
+
+\wxheading{Parameters}
+
+\docparam{depth}{Bitmap depth.}
+
+\membersection{wxBitmap::SetHeight}\label{wxbitmapsetheight}
+
+\func{void}{SetHeight}{\param{int }{height}}
+
+Sets the height member (does not affect the bitmap data).
+
+\wxheading{Parameters}
+
+\docparam{height}{Bitmap height in pixels.}
+
+\membersection{wxBitmap::SetMask}\label{wxbitmapsetmask}
+
+\func{void}{SetMask}{\param{wxMask* }{mask}}
+
+Sets the mask for this bitmap.
+
+\wxheading{Remarks}
+
+The bitmap object owns the mask once this has been called.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::GetMask}{wxbitmapgetmask}, \helpref{wxMask}{wxmask}
+
+\membersection{wxBitmap::SetOk}
+
+\func{void}{SetOk}{\param{int }{isOk}}
+
+Sets the validity member (does not affect the bitmap data).
+
+\wxheading{Parameters}
+
+\docparam{isOk}{Validity flag.}
+
+\membersection{wxBitmap::SetPalette}\label{wxbitmapsetpalette}
+
+\func{void}{SetPalette}{\param{wxPalette* }{palette}}
+
+Sets the associated palette: it will be deleted in the wxBitmap
+destructor, so if you do not wish it to be deleted automatically,
+reset the palette to NULL before the bitmap is deleted.
+
+\wxheading{Parameters}
+
+\docparam{palette}{The palette to set.}
+
+\wxheading{Remarks}
+
+The bitmap object owns the palette once this has been called.
+
+\wxheading{See also}
+
+\helpref{wxPalette}{wxpalette}
+
+\membersection{wxBitmap::SetWidth}
+
+\func{void}{SetWidth}{\param{int }{width}}
+
+Sets the width member (does not affect the bitmap data).
+
+\wxheading{Parameters}
+
+\docparam{width}{Bitmap width in pixels.}
+
+\membersection{wxBitmap::operator $=$}
+
+\func{wxBitmap\& }{operator $=$}{\param{const wxBitmap\& }{bitmap}}
+
+Assignment operator. This operator does not copy any data, but instead
+passes a pointer to the data in {\it bitmap} and increments a reference
+counter. It is a fast operation.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{Bitmap to assign.}
+
+\wxheading{Return value}
+
+Returns 'this' object.
+
+\membersection{wxBitmap::operator $==$}
+
+\func{bool}{operator $==$}{\param{const wxBitmap\& }{bitmap}}
+
+Equality operator. This operator tests whether the internal data pointers are
+equal (a fast test).
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{Bitmap to compare with 'this'}
+
+\wxheading{Return value}
+
+Returns TRUE if the bitmaps were effectively equal, FALSE otherwise.
+
+\membersection{wxBitmap::operator $!=$}
+
+\func{bool}{operator $!=$}{\param{const wxBitmap\& }{bitmap}}
+
+Inequality operator. This operator tests whether the internal data pointers are
+unequal (a fast test).
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{Bitmap to compare with 'this'}
+
+\wxheading{Return value}
+
+Returns TRUE if the bitmaps were unequal, FALSE otherwise.
+
+\section{\class{wxBitmapHandler}}\label{wxbitmaphandler}
+
+\overview{Overview}{wxbitmapoverview}
+
+This is the base class for implementing bitmap file loading/saving, and bitmap creation from data.
+It is used within wxBitmap and is not normally seen by the application.
+
+If you wish to extend the capabilities of wxBitmap, derive a class from wxBitmapHandler
+and add the handler using \helpref{wxBitmap::AddHandler}{wxbitmapaddhandler} in your
+application initialisation.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxBitmap}{wxbitmap}, \helpref{wxIcon}{wxicon}, \helpref{wxCursor}{wxcursor}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxBitmapHandler::wxBitmapHandler}\label{wxbitmaphandlerconstr}
+
+\func{}{wxBitmapHandler}{\void}
+
+Default constructor. In your own default constructor, initialise the members
+m\_name, m\_extension and m\_type.
+
+\membersection{wxBitmapHandler::\destruct{wxBitmapHandler}}
+
+\func{}{\destruct{wxBitmapHandler}}{\void}
+
+Destroys the wxBitmapHandler object.
+
+\membersection{wxBitmapHandler::Create}
+
+\func{virtual bool}{Create}{\param{wxBitmap* }{bitmap}, \param{void*}{ data}, \param{int}{ type}, \param{int}{ width}, \param{int}{ height}, \param{int}{ depth = -1}}
+
+Creates a bitmap from the given data, which can be of arbitrary type. The wxBitmap object {\it bitmap} is
+manipulated by this function.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The wxBitmap object.}
+
+\docparam{width}{The width of the bitmap in pixels.}
+
+\docparam{height}{The height of the bitmap in pixels.}
+
+\docparam{depth}{The depth of the bitmap in pixels. If this is -1, the screen depth is used.}
+
+\docparam{data}{Data whose type depends on the value of {\it type}.}
+
+\docparam{type}{A bitmap type identifier - see \helpref{wxBitmapHandler::wxBitmapHandler}{wxbitmapconstr} for a list
+of possible values.}
+
+\wxheading{Return value}
+
+TRUE if the call succeeded, FALSE otherwise (the default).
+
+\membersection{wxBitmapHandler::GetName}
+
+\constfunc{wxString}{GetName}{\void}
+
+Gets the name of this handler.
+
+\membersection{wxBitmapHandler::GetExtension}
+
+\constfunc{wxString}{GetExtension}{\void}
+
+Gets the file extension associated with this handler.
+
+\membersection{wxBitmapHandler::GetType}
+
+\constfunc{long}{GetType}{\void}
+
+Gets the bitmap type associated with this handler.
+
+\membersection{wxBitmapHandler::LoadFile}\label{wxbitmaphandlerloadfile}
+
+\func{bool}{LoadFile}{\param{wxBitmap* }{bitmap}, \param{const wxString\&}{ name}, \param{long}{ type}}
+
+Loads a bitmap from a file or resource, putting the resulting data into {\it bitmap}.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The bitmap object which is to be affected by this operation.}
+
+\docparam{name}{Either a filename or a Windows resource name.
+The meaning of {\it name} is determined by the {\it type} parameter.}
+
+\docparam{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for values this can take.}
+
+\wxheading{Return value}
+
+TRUE if the operation succeeded, FALSE otherwise.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}\\
+\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}\\
+\helpref{wxBitmapHandler::SaveFile}{wxbitmaphandlersavefile}
+
+\membersection{wxBitmapHandler::SaveFile}\label{wxbitmaphandlersavefile}
+
+\func{bool}{SaveFile}{\param{wxBitmap* }{bitmap}, \param{const wxString\& }{name}, \param{int}{ type}, \param{wxPalette* }{palette = NULL}}
+
+Saves a bitmap in the named file.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The bitmap object which is to be affected by this operation.}
+
+\docparam{name}{A filename. The meaning of {\it name} is determined by the {\it type} parameter.}
+
+\docparam{type}{See \helpref{wxBitmap::wxBitmap}{wxbitmapconstr} for values this can take.}
+
+\docparam{palette}{An optional palette used for saving the bitmap. TODO: this parameter should
+probably be eliminated; instead the app should set the palette before saving.}
+
+\wxheading{Return value}
+
+TRUE if the operation succeeded, FALSE otherwise.
+
+\wxheading{See also}
+
+\helpref{wxBitmap::LoadFile}{wxbitmaploadfile}\\
+\helpref{wxBitmap::SaveFile}{wxbitmapsavefile}\\
+\helpref{wxBitmapHandler::LoadFile}{wxbitmaphandlerloadfile}
+
+\membersection{wxBitmapHandler::SetName}
+
+\func{void}{SetName}{\param{const wxString\& }{name}}
+
+Sets the handler name.
+
+\wxheading{Parameters}
+
+\docparam{name}{Handler name.}
+
+\membersection{wxBitmapHandler::SetExtension}
+
+\func{void}{SetExtension}{\param{const wxString\& }{extension}}
+
+Sets the handler extension.
+
+\wxheading{Parameters}
+
+\docparam{extension}{Handler extension.}
+
+\membersection{wxBitmapHandler::SetType}
+
+\func{void}{SetType}{\param{long }{type}}
+
+Sets the handler type.
+
+\wxheading{Parameters}
+
+\docparam{name}{Handler type.}
+
+

docs/latex/wx/body.tex

@@ -0,0 +1,811 @@
+\chapter{Introduction}\label{introduction}
+\pagenumbering{arabic}%
+\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+
+\section{What is wxWindows?}
+
+wxWindows is a C++ framework providing GUI (Graphical User
+Interface) and other facilities on more than one platform.  Version 2.0 currently
+supports subsets MS Windows (16-bit, Windows 95 and Windows NT) and GTK.
+
+wxWindows was originally developed at the Artificial Intelligence
+Applications Institute, University of Edinburgh, for internal use.
+wxWindows has been released into the public domain in the hope
+that others will also find it useful. Version 2.0 is written and
+maintained by Julian Smart, Robert Roebling and others.
+
+This manual discusses wxWindows in the context of multi-platform
+development.\helpignore{For more detail on the wxWindows version 2.0 API
+(Application Programming Interface) please refer to the separate
+wxWindows reference manual.}
+
+Please note that in the following, ``MS Windows" often refers to all
+platforms related to Microsoft Windows, including 16-bit and 32-bit
+variants, unless otherwise stated. All trademarks are acknowledged.
+
+\section{Why another cross-platform development tool?}
+
+wxWindows was developed to provide a cheap and flexible way to maximize
+investment in GUI application development.  While a number of commercial
+class libraries already exist for cross-platform development,
+none met all of the following criteria:
+
+\begin{enumerate}\itemsep=0pt
+\item low price;
+\item source availability;
+\item simplicity of programming;
+\item support for a wide range of compilers.
+\end{enumerate}
+
+As public domain software and a project open to everyone, wxWindows has
+benefited from comments, ideas, bug fixes, enhancements and the sheer
+enthusiasm of users, especially via the Internet. This gives wxWindows a
+certain advantage over its commercial brothers, and a robustness against
+the transience of one individual or company. This openness and
+availability of source code is especially important when the future of
+thousands of lines of application code may depend upon the longevity of
+the underlying class library.
+
+In writing wxWindows, completeness has sometimes been traded for
+portability and simplicity of programming. Version 2.0 goes much
+further than previous versions in terms of generality and features,
+allowing applications to be produced
+that are often indistinguishable from those produced using single-platform
+toolkits
+such as Motif and MFC.
+
+wxWindows 2.0 currently maps to two native APIs: GTK and
+MS Windows. Motif, Xt and Mac ports are also in preparation.
+
+The importance of using a platform-independent class library cannot be
+overstated, since GUI application development is very time-consuming,
+and sustained popularity of particular GUIs cannot be guaranteed.
+Code can very quickly become obsolete if it addresses the wrong
+platform or audience.  wxWindows helps to insulate the programmer from
+these winds of change. Although wxWindows may not be suitable for
+every application, it provides access to most of the functionality a
+GUI program normally requires, plus some extras such as form
+construction, interprocess communication and PostScript output, and
+can of course be extended as needs dictate.  As a bonus, it provides
+a cleaner programming interface than the native
+APIs. Programmers may find it worthwhile to use wxWindows even if they
+are developing on only one platform.
+
+It is impossible to sum up the functionality of wxWindows in a few paragraphs, but
+here are some of the benefits:
+
+\begin{itemize}\itemsep=0pt
+\item Low cost (free, in fact!)
+\item You get the source.
+\item Several example programs.
+\item Over 700 pages of printable and on-line documentation.
+\item Simple-to-use, object-oriented API.
+\item Graphics calls include splines, polylines, rounded rectangles, etc.
+\item Constraint-based layout option.
+\item Print/preview and document/view architectures.
+\item Status line facility, toolbar
+\item Easy, object-oriented interprocess comms (DDE subset) under Unix and
+MS Windows.
+\item Encapsulated PostScript generation under Unix, normal MS Windows printing on the
+PC.
+\item MDI support under Windows and GTK.
+\item Can be used to create DLLs under Windows, dynamic libraries on the Sun.
+\item Common dialogs for file browsing, printing, colour selection, etc.
+\item Under MS Windows, support for creating metafiles and copying
+them to the clipboard.
+\item Hypertext help facility, with an API for invocation from applications.
+\item Dialog Editor for building dialogs.
+\end{itemize}
+
+\section{Changes from version 1.xx}\label{versionchanges}
+
+These are a few of the major differences between versions 1.xx and 2.0.
+
+Removals:
+
+\begin{itemize}\itemsep=0pt
+\item XView is no longer supported;
+\item Mac is not yet supported;
+\item all controls (panel items) no longer have labels attached to them;
+\item wxForm removed;
+\item wxCanvasDC, wxPanelDC removed (replaced by wxClientDC, wxWindowDC, wxPaintDC which
+can be used for any window);
+\item wxMultiText, wxTextWindow, wxText removed and replaced by wxTextCtrl;
+\item classes no longer divided into generic and platform-specific parts, for efficiency.
+\end{itemize}
+
+Additions and changes:
+
+\begin{itemize}\itemsep=0pt
+\item class hierarchy changed, and restrictions about subwindow nesting lifted;
+\item header files reorganised to conform to normal C++ standards;
+\item classes less dependent on each another, to reduce executable size;
+\item wxString used instead of char* wherever possible;
+\item the number of separate but mandatory utilities reduced;
+\item the event system has been overhauled, with
+virtual functions and callbacks being replaced with MFC-like event tables;
+\item new controls, such as wxTreeCtrl, wxListCtrl, wxSpinButton;
+\item less inconsistency about what events can be handled, so for example
+mouse clicks or key presses on controls can now be intercepted;
+\item the status bar is now a separate class, wxStatusBar, and is
+implemented in generic wxWindows code;
+\item some renaming of controls for greater consistency;
+\item wxBitmap has the notion of bitmap handlers to allow for extension to new formats
+without ifdefing;
+\item new dialogs: wxPageSetupDialog, wxFileDialog, wxDirDialog,
+wxMessageDialog, wxSingleChoiceDialog, wxTextEntryDialog;
+\item GDI objects are reference-counted and are now passed to most functions
+by reference, making memory management far easier;
+\item wxSystemSettings class allows querying for various system-wide properties
+such as dialog font, colours, user interface element sizes, and so on;
+\item better platform look and feel conformance;
+\item toolbar functionality now separated out into a family of classes with the
+same API;
+\item device contexts are no longer accessed using wxWindow::GetDC - they are created
+temporarily with the window as an argument;
+\item events from sliders and scrollbars can be handled more flexibly;
+\item the handling of window close events has been changed in line with the new
+event system, but backward {\bf OnClose} compatibility has been retained;
+\item the concept of {\it validator} has been added to allow much easier coding of
+the relationship between controls and application data;
+\item the documentation has been revised, with more cross-referencing.
+\end{itemize}
+
+Platform-specific changes:
+
+\begin{itemize}\itemsep=0pt
+\item The Windows header file (windows.h) is no longer included by wxWindows headers;
+\item wx.dll supported under Visual C++;
+\item the full range of Windows 95 window decorations are supported, such as modal frame
+borders;
+\item MDI classes brought out of wxFrame into separate classes, and made more flexible.
+\end{itemize}
+
+\section{wxWindows requirements}\label{requirements}
+
+To make use of wxWindows, you currently need one or both of the
+following setups.
+
+(a) PC:
+
+\begin{enumerate}\itemsep=0pt
+\item A 486 or higher PC running MS Windows.
+\item One of Microsoft Visual C++ 4.0 or higher, Borland C++, Gnu-Win32.
+\item At least 60 MB of disk space.
+\end{enumerate}
+
+(b) Unix:
+
+\begin{enumerate}\itemsep=0pt
+\item Almost any C++ compiler, including GNU C++.
+\item Almost any Unix workstation, and GTK 1.0 or higher.
+\item At least 60 MB of disk space.
+\end{enumerate}
+
+\section{Availability and location of wxWindows}
+
+wxWindows is currently available from the Artificial Intelligence
+Applications Institute by anonymous FTP and World Wide Web:
+
+\begin{verbatim}
+  ftp://ftp.aiai.ed.ac.uk/pub/packages/wxwin
+  http://web.ukonline.co.uk/julian.smart/wxwin
+\end{verbatim}
+
+\section{Acknowledgments}
+
+Thanks are due to AIAI for being willing to release the original version of
+wxWindows into the public domain, and to our patient wives Harriet, Tanja and others.
+
+We would particularly like to thank the following for their contributions to wxWindows, and the many others who have been involved in
+the project over the years. Apologies for any unintentional omissions from this list. 
+ 
+Yiorgos Adamopoulos, Jamshid Afshar, Alejandro Aguilar-Sierra, AIAI, Patrick Albert, Karsten Ballueder, Michael Bedward, Kai Bendorf, Yura Bidus, Keith 
+Gary Boyce, Chris Breeze, Pete Britton, Ian Brown, C. Buckley, Dmitri Chubraev, Robin Corbet, Cecil Coupe, Andrew Davison, Neil Dudman, Robin 
+Dunn, Hermann Dunkel, Jos van Eijndhoven, Tom Felici, Thomas Fettig, Matthew Flatt, Pasquale Foggia, Josep Fortiana, Todd Fries, Dominic Gallagher, 
+Wolfram Gloger, Norbert Grotz, Stefan Gunter, Bill Hale, Patrick Halke, Stefan Hammes, Guillaume Helle, Harco de Hilster, Cord Hockemeyer, Markus 
+Holzem, Olaf Klein, Leif Jensen, Bart Jourquin, Guilhem Lavaux, Jan Lessner, Nicholas Liebmann, Torsten Liermann, Per Lindqvist, Thomas Runge, Tatu
+M\"{a}nnist\"{o}, Scott Maxwell, Thomas Myers, Oliver Niedung, Hernan Otero, Ian Perrigo, Timothy Peters, Giordano Pezzoli, Harri Pasanen, Thomaso Paoletti, 
+Garrett Potts, Marcel Rasche, Robert Roebling, Dino Scaringella, Jobst Schmalenbach, Arthur Seaton, Paul Shirley, Stein Somers, Petr Smilauer, Neil Smith, 
+Kari Syst\"{a}, Arthur Tetzlaff-Deas, Jonathan Tonberg, Jyrki Tuomi, Janos Vegh, Andrea Venturoli, Vadim Zeitlin, Xiaokun Zhu, Edward Zimmermann.
+
+`Graphplace', the basis for the wxGraphLayout library, is copyright Dr. Jos
+T.J. van Eijndhoven of Eindhoven University of Technology. The code has
+been used in wxGraphLayout with his permission.
+
+We also acknowledge the author of XFIG, the excellent Unix drawing tool,
+from the source of which we have borrowed some spline drawing code.
+His copyright is included below.
+
+{\it XFig2.1 is copyright (c) 1985 by Supoj Sutanthavibul. Permission to
+use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided
+that the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation, and that the name of M.I.T. not be used in advertising or
+publicity pertaining to distribution of the software without specific,
+written prior permission.  M.I.T. makes no representations about the
+suitability of this software for any purpose.  It is provided ``as is''
+without express or implied warranty.}
+
+\chapter{Multi-platform development with wxWindows}\label{multiplat}
+\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+
+This chapter describes the practical details of using wxWindows. Please
+see the file install.txt for up-to-date installation instructions, and
+changes.txt for differences between versions.
+
+\section{Include files}
+
+The main include file is {\tt "wx/wx.h"}; this includes the most commonly
+used modules of wxWindows.
+
+To save on compilation time, include only those header files relevant to the
+source file. If you are using precompiled headers, you should include
+the following section before any other includes:
+
+\begin{verbatim}
+// For compilers that support precompilation, includes "wx.h".
+#include <wx/wxprec.h>
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+// Include your minimal set of headers here, or wx.h
+#include <wx/wx.h>
+#endif
+
+... now your other include files ...
+\end{verbatim}
+
+The file {\tt "wx/wxprec.h"} includes {\tt "wx/wx.h"}. Although this incantation
+may seem quirky, it is in fact the end result of a lot of experimentation,
+and several Windows compilers to use precompilation (those tested are Microsoft Visual C++, Borland C++
+and Watcom C++).
+
+Borland precompilation is largely automatic. Visual C++ requires specification of {\tt "wx/wxprec.h"} as
+the file to use for precompilation. Watcom C++ is automatic apart from the specification of
+the .pch file. Watcom C++ is strange in requiring the precompiled header to be used only for
+object files compiled in the same directory as that in which the precompiled header was created.
+Therefore, the wxWindows Watcom C++ makefiles go through hoops deleting and recreating
+a single precompiled header file for each module, thus preventing an accumulation of many
+multi-megabyte .pch files.
+
+\section{Libraries}
+
+Please the wxGTK documentation for use of the Unix version of wxWindows.
+Under Windows, use the library wx.lib for stand-alone Windows
+applications, or wxdll.lib for creating DLLs.
+
+\section{Configuration}
+
+The following lists the options configurable in the file
+\rtfsp{\tt "wx/msw/setup.h"} and {\tt "wx/gtk/setup.h"} Some settings are a matter
+of taste, some help with platform-specific problems, and
+others can be set to minimize the size of the library.
+
+\subsection{General features}
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{USE\_CLIPBOARD}{If 1, clipboard code is compiled (Windows only).}
+\twocolitem{USE\_CONSTRAINTS}{If 1, the constaint-based window layout system is compiled.}
+\twocolitem{USE\_DOC\_VIEW\_ARCHITECTURE}{If 1, wxDocument, wxView and related classes are compiled.}
+\twocolitem{USE\_DYNAMIC\_CLASSES}{If 1, the run-time class macros and classes are compiled. Recommended,
+and necessary for the document/view framework.}
+\twocolitem{USE\_HELP}{If 1, interface to help system is compiled.}
+\twocolitem{USE\_GAUGE}{If 1, the wxGauge class compiled.}
+\twocolitem{USE\_GLOBAL\_MEMORY\_OPERATORS}{If 1, redefines global new and delete operators to be compatible
+with the extended arguments of the debugging wxObject new and delete operators. If this causes problems
+for your compiler, set to 0.}
+\twocolitem{USE\_IPC}{If 1, interprocess communication code is compiled.}
+\twocolitem{USE\_MEMORY\_TRACING}{If 1, enables debugging versions of wxObject::new and wxObject::delete
+if the value of DEBUG is defined to more than 0.}
+\twocolitem{USE\_METAFILE}{If 1, Windows Metafile code is compiled.}
+\twocolitem{USE\_POSTSCRIPT}{If 1, PostScript code is compiled.}
+\twocolitem{USE\_POSTSCRIPT\_ARCHITECTURE\_IN\_MSW}{Set to 1 to enable the printing architecture
+to make use of either native Windows printing facilities, or the wxPostScriptDC class depending
+on the wxApp::SetPrintMode setting.}
+\twocolitem{USE\_PRINTING\_ARCHITECTURE}{If 1, wxPrinter, wxPrintout and related classes are compiled
+for the print/preview framework.}
+\twocolitem{USE\_RESOURCES}{If 1, win.ini or .Xdefaults-style resource read/write code is compiled.}
+\twocolitem{USE\_WX\_RESOURCES}{If 1, wxWindows resource file (.WXR) code is compiled.}
+\end{twocollist}
+
+\subsection{Windows and NT features}
+
+\begin{twocollist}
+\twocolitem{CTL3D}{CTL3D should only be used for 16-bit Windows programs.
+On Windows 95 and NT, native 3D effects are used. If you want to
+use it and don't already have CTL3D installed, copy the files in
+contrib/ctl3d to appropriate places (ctl3dv2.lib/ctl3d32.lib into your compiler lib
+directory, ctl3d.h into an include directory, and ctl3dv2.dll into
+windows/system). You may need to find a compiler-specific version of ctl3dv2.lib
+or ctl3d32.lib. Define CTL3D to be 1 in wx\_setup.h and link your executables with ctl3dv2.lib
+or ctl3d32.lib.}
+\twocolitem{USE\_ODBC}{If 1, compiles wxDatabase and wxRecordSet classes for ODBC
+access. Requires sql.h, sqlext.h files if set to 1 (see topic on database support).}
+\end{twocollist}
+
+\section{Makefiles}
+
+At the moment there is no attempt to make Unix makefiles and
+PC makefiles compatible, i.e. one makefile is required for
+each environment.
+
+Sample makefiles for Unix (suffix .UNX), MS C++ (suffix .DOS and .NT), Borland
+C++ (.BCC) and Symantec C++ (.SC) are included for the library, demos
+and utilities. The NT, Borland and Symantec makefiles cannot be
+guaranteed to be up-to-date since the author does not have
+these compilers.
+
+The controlling makefile for wxWindows is in the platform-specific
+directory, such as {\tt src/msw} or {\tt src/x}. This makefile will
+recursively execute the makefile in {\tt src/base}.
+
+\subsection{Windows makefiles}
+
+For Microsoft C++, normally it is only necessary to type {\tt nmake -f
+makefile.dos} (or an alias or batch file which does this). By default,
+binaries are made with debugging information, and no optimization. Use
+FINAL=1 on the command line to remove debugging information (this only
+really necessary at the link stage), and DLL=1 to make a DLL version of
+the library, if building a library.
+
+\subsection{Unix makefiles}
+
+TODO.
+
+Debugging information is included by default; you may add DEBUG= as an
+argument to make to compile without it, or use the Unix {\bf strip}
+command to remove debugging information from an executable.
+
+\normalbox{{\it Important note:} Most compiler flags are kept centrally in
+src/make.env, which is included by all other makefiles. This is the
+file to edit to tailor wxWindows compilation to your environment.}
+
+\section{Windows-specific files}
+
+wxWindows application compilation under MS Windows requires at least two
+extra files, resource and module definition files.
+
+\subsection{Resource file}\label{resources}
+
+The least that must be defined in the Windows resource file (extension RC)
+is the following statement:
+
+\begin{verbatim}
+rcinclude "wx/msw/wx.rc"
+\end{verbatim}
+
+which includes essential internal wxWindows definitions.  The resource script
+may also contain references to icons, cursors, etc., for example:
+
+\begin{verbatim}
+wxicon icon wx.ico
+\end{verbatim}
+
+The icon can then be referenced by name when creating a frame icon. See
+the MS Windows SDK documentation.
+
+\normalbox{Note: include wx.rc {\it after} any ICON statements
+so programs that search your executable for icons (such
+as the Program Manager) find your application icon first.}
+
+\subsection{Module definition file}
+
+A module definition file (extension DEF) is required for 16-bit applications, and
+looks like the following:
+
+\begin{verbatim}
+NAME         Hello
+DESCRIPTION  'Hello'
+EXETYPE      WINDOWS
+STUB         'WINSTUB.EXE'
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+HEAPSIZE     1024
+STACKSIZE    8192
+\end{verbatim}
+
+The only lines which will usually have to be changed per application are
+NAME and DESCRIPTION.
+
+\subsection{Allocating and deleting wxWindows objects}
+
+In general, classes derived from wxWindow must dynamically allocated
+with {\it new} and deleted with {\it delete}. If you delete a window,
+all of its children and descendants will be automatically deleted,
+so you don't need to delete these descendants explicitly.
+
+When deleting a frame or dialog, use {\bf Destroy} rather than {\bf delete} so
+that the wxWindows delayed deletion can take effect. This waits until idle time
+(when all messages have been processed) to actually delete the window, to avoid
+problems associated with the GUI sending events to deleted windows.
+
+Don't create a window on the stack, because this will interfere
+with delayed deletion.
+
+If you decide to allocate a C++ array of objects (such as wxBitmap) that may
+be cleaned up by wxWindows, make sure you delete the array explicitly
+before wxWindows has a chance to do so on exit, since calling {\it delete} on
+array members will cause memory problems.
+
+wxColour can be created statically: it is not automatically cleaned
+up and is unlikely to be shared between other objects; it is lightweight
+enough for copies to be made.
+
+Beware of deleting objects such as a wxPen or wxBitmap if they are still in use.
+Windows is particularly sensitive to this: so make sure you
+make calls like wxDC::SetPen(wxNullPen) or wxDC::SelectObject(wxNullBitmap) before deleting
+a drawing object that may be in use. Code that doesn't do this will probably work
+fine on some platforms, and then fail under Windows.
+
+\section{Conditional compilation}
+
+One of the purposes of wxWindows is to reduce the need for conditional
+compilation in source code, which can be messy and confusing to follow.
+However, sometimes it is necessary to incorporate platform-specific
+features (such as metafile use under MS Windows). The following identifiers
+may be used for this purpose, along with any user-supplied ones:
+
+{\bf GUIs:}
+
+\begin{verbatim}
+__X__           any X, but not GTK
+__WXMOTIF__     Motif
+__WXGTK__       GTK
+__WXMSW__       Any Windows
+__MAC__         MacOS
+__UNIX__        any Unix
+__WIN95__       GUI for Windows 95 and above; NT 4.0 and above.
+__WIN32__       WIN32 API
+__NT__          Windows NT
+__CURSES__      CURSES
+\end{verbatim}
+
+{\bf OSes:}
+
+\begin{verbatim}
+__HPUX__
+__SVR4__
+__SYSV__
+__LINUX__
+__SGI__
+__ULTRIX__
+__BSD__
+__VMS__
+__SUN__         Any Sun
+__SUNOS__
+__SOLARIS__
+__ALPHA__
+__AIX__
+__DATA_GENERAL__
+__OSF__
+__FREEBSD__
+\end{verbatim}
+
+{\bf Compilers:}
+
+\begin{verbatim}
+__GNUWIN32__    Gnu-Win32 compiler
+__DJGPP__       DJGPP
+__GNUG__        Gnu C++ on any platform
+__BORLANDC__    Borland C++
+__WATCOMC__     Watcom C++
+__SYMANTECC__   Symantec C++
+__VISUALC__     VC++
+__SUNCC__
+\end{verbatim}
+
+{\bf wxWindows modes:}
+
+\begin{verbatim}
+__WXDEBUG__       usage: #ifdef __DEBUG__ (=> debug mode, else => release)
+\end{verbatim}
+
+
+\section{C++ issues}
+
+The following documents some miscellaneous C++ issues.
+
+\subsection{Templates}
+
+wxWindows does not use templates since it is a notoriously unportable feature.
+
+\subsection{Precompiled headers}
+
+Some compilers, such as Borland C++ and Microsoft C++, support
+precompiled headers. This can save a great deal of compiling time. The
+recommended approach is to precompile {\tt ``wx.h''}, using this
+precompiled header for compiling both wxWindows itself and any
+wxWindows applications. For Windows compilers, two dummy source files
+are provided (one for normal applications and one for creating DLLs)
+to allow initial creation of the precompiled header.
+
+However, there are several downsides to using precompiled headers. One
+is that to take advantage of the facility, you often need to include
+more header files than would normally be the case. This means that
+changing a header file will cause more recompilations (in the case of
+wxWindows, everything needs to be recompiled since everything includes
+{\tt ``wx.h''}!)
+
+A related problem is that for compilers that don't have precompiled
+headers, including a lot of header files slows down compilation
+considerably. For this reason, you will find (in the common
+X and Windows parts of the library) conditional
+compilation that under Unix, includes a minimal set of headers;
+and when using Visual C++, includes {\tt wx.h}. This should help provide
+the optimal compilation for each compiler, although it is
+biassed towards the precompiled headers facility available
+in Microsoft C++.
+
+\section{File handling}
+
+When building an application which may be used under different
+environments, one difficulty is coping with documents which may be
+moved to different directories on other machines. Saving a file which
+has pointers to full pathnames is going to be inherently unportable. One
+approach is to store filenames on their own, with no directory
+information.  The application searches through a number of locally
+defined directories to find the file. To support this, the class {\bf
+wxPathList} makes adding directories and searching for files easy, and
+the global function {\bf FileNameFromPath} allows the application to
+strip off the filename from the path if the filename must be stored.
+This has undesirable ramifications for people who have documents of the
+same name in different directories.
+
+As regards the limitations of DOS 8+3 single-case filenames versus
+unrestricted Unix filenames, the best solution is to use DOS filenames
+for your application, and also for document filenames {\it if} the user
+is likely to be switching platforms regularly. Obviously this latter
+choice is up to the application user to decide.  Some programs (such as
+YACC and LEX) generate filenames incompatible with DOS; the best
+solution here is to have your Unix makefile rename the generated files
+to something more compatible before transferring the source to DOS.
+Transferring DOS files to Unix is no problem, of course, apart from EOL
+conversion for which there should be a utility available (such as
+dos2unix).
+
+See also the File Functions section of the reference manual for
+descriptions of miscellaneous file handling functions.
+
+\chapter{Utilities supplied with wxWindows}\label{utilities}
+\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+
+A number of `extras' are supplied with wxWindows, to complement
+the GUI functionality in the main class library. These are found
+below the utils directory and usually have their own source, library
+and documentation directories. For larger user-contributed packages,
+see the directory /pub/packages/wxwin/contrib.
+
+\section{wxHelp}\label{wxhelp}
+
+wxHelp is a stand-alone program, written using wxWindows,
+for displaying hypertext help. It is necessary since not all target
+systems (notably X) supply an adequate
+standard for on-line help. wxHelp is modelled on the MS Windows help
+system, with contents, search and browse buttons, but does not reformat
+text to suit the size of window, as WinHelp does, and its input files
+are uncompressed ASCII with some embedded font commands and an .xlp
+extension. Most wxWindows documentation (user manuals and class
+references) is supplied in wxHelp format, and also in Windows Help
+format. The wxWindows 2.0 project will presently use an HTML widget
+in a new and improved wxHelp implementation, under X.
+
+Note that an application can be programmed to use Windows Help under
+MS Windows, and wxHelp under X. An alternative help viewer under X is
+Mosaic, a World Wide Web viewer that uses HTML as its native hypertext
+format. However, this is not currently integrated with wxWindows
+applications.
+
+wxHelp works in two modes---edit and end-user. In edit mode, an ASCII
+file may be marked up with different fonts and colours, and divided into
+sections. In end-user mode, no editing is possible, and the user browses
+principally by clicking on highlighted blocks.
+
+When an application invokes wxHelp, subsequent sections, blocks or
+files may be viewed using the same instance of wxHelp since the two
+programs are linked using wxWindows interprocess communication
+facilities. When the application exits, that application's instance of
+wxHelp may be made to exit also.  See the {\bf wxHelpControllerBase} entry in the
+reference section for how an application controls wxHelp.
+
+\section{Tex2RTF}\label{textortf}
+
+Supplied with wxWindows is a utility called Tex2RTF for converting\rtfsp
+\LaTeX\ manuals to the following formats:
+
+\begin{description}
+\item[wxHelp]
+wxWindows help system format (XLP).
+\item[Linear RTF]
+Rich Text Format suitable for importing into a word processor.
+\item[Windows Help RTF]
+Rich Text Format suitable for compiling into a WinHelp HLP file with the
+help compiler.
+\item[HTML]
+HTML is the native format for Mosaic, the main hypertext viewer for
+the World Wide Web. Since it is freely available it is a good candidate
+for being the wxWindows help system under X, as an alternative to wxHelp.
+\end{description}
+
+Tex2RTF is used for the wxWindows manuals and can be used independently
+by authors wishing to create on-line and printed manuals from the same\rtfsp
+\LaTeX\ source.  Please see the separate documentation for Tex2RTF.
+
+\section{wxTreeLayout}
+
+This is a simple class library for drawing trees in a reasonably pretty
+fashion. It provides only minimal default drawing capabilities, since
+the algorithm is meant to be used for implementing custom tree-based
+tools.
+
+Directed graphs may also be drawn using this library, if cycles are
+removed before the nodes and arcs are passed to the algorithm.
+
+Tree displays are used in many applications: directory browsers,
+hypertext systems, class browsers, and decision trees are a few
+possibilities.
+
+See the separate manual and the directory utils/wxtree.
+
+\section{wxGraphLayout}
+
+The wxGraphLayout class is based on a tool called `graphplace' by Dr.
+Jos T.J. van Eijndhoven of Eindhoven University of Technology. Given a
+(possibly cyclic) directed graph, it does its best to lay out the nodes
+in a sensible manner. There are many applications (such as diagramming)
+where it is required to display a graph with no human intervention. Even
+if manual repositioning is later required, this algorithm can make a good
+first attempt.
+
+See the separate manual and the directory utils/wxgraph. 
+
+\section{Colours}\label{coloursampler}
+
+A colour sampler for viewing colours and their names on each
+platform.
+
+%
+\chapter{Tutorial}\label{tutorial}
+\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+
+To be written.
+
+\chapter{Programming strategies}\label{strategies}
+\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+
+This chapter is intended to list strategies that may be useful when
+writing and debugging wxWindows programs. If you have any good tips,
+please submit them for inclusion here.
+
+\section{Strategies for reducing programming errors}
+
+\subsection{Use ASSERT}
+
+Although I haven't done this myself within wxWindows, it is good
+practice to use ASSERT statements liberally, that check for conditions that
+should or should not hold, and print out appropriate error messages.
+These can be compiled out of a non-debugging version of wxWindows
+and your application. Using ASSERT is an example of `defensive programming':
+it can alert you to problems later on.
+
+\subsection{Use wxString in preference to character arrays}
+
+Using wxString can be much safer and more convenient than using char *.
+Again, I haven't practised what I'm preaching, but I'm now trying to use
+wxString wherever possible. You can reduce the possibility of memory
+leaks substantially, and it's much more convenient to use the overloaded
+operators than functions such as strcmp. wxString won't add a significant
+overhead to your program; the overhead is compensated for by easier
+manipulation (which means less code).
+
+The same goes for other data types: use classes wherever possible.
+
+\section{Strategies for portability}
+
+\subsection{Use relative positioning or constraints}
+
+Don't use absolute panel item positioning if you can avoid it. Different GUIs have
+very differently sized panel items. Consider using the constraint system, although this
+can be complex to program. If you needs are simple, the default relative positioning
+behaviour may be adequate (using default position values and wxPanel::NewLine).
+
+Alternatively, you could use alternative .wrc (wxWindows resource files) on different
+platforms, with slightly different dimensions in each. Or space your panel items out
+to avoid problems.
+
+\subsection{Use wxWindows resource files}
+
+Use .wrc (wxWindows resource files) where possible, because they can be easily changed
+independently of source code. Bitmap resources can be set up to load different
+kinds of bitmap depending on platform (see the section on resource files).
+
+\section{Strategies for debugging}\label{debugstrategies}
+
+\subsection{Positive thinking}
+
+It's common to blow up the problem in one's imagination, so that it seems to threaten
+weeks, months or even years of work. The problem you face may seem insurmountable:
+but almost never is. Once you have been programming for some time, you will be able
+to remember similar incidents that threw you into the depths of despair. But
+remember, you always solved the problem, somehow!
+
+Perseverance is often the key, even though a seemingly trivial problem
+can take an apparently inordinate amount of time to solve. In the end,
+you will probably wonder why you worried so much. That's not to say it
+isn't painful at the time. Try not to worry -- there are many more important
+things in life.
+
+\subsection{Simplify the problem}
+
+Reduce the code exhibiting the problem to the smallest program possible
+that exhibits the problem. If it is not possible to reduce a large and
+complex program to a very small program, then try to ensure your code
+doesn't hide the problem (you may have attempted to minimize the problem
+in some way: but now you want to expose it).
+
+With luck, you can add a small amount of code that causes the program
+to go from functioning to non-functioning state. This should give a clue
+to the problem. In some cases though, such as memory leaks or wrong
+deallocation, this can still give totally spurious results!
+
+\subsection{Use a debugger}
+
+This sounds like facetious advice, but it's surprising how often people
+don't use a debugger. Often it's an overhead to install or learn how to
+use a debugger, but it really is essential for anything but the most
+trivial programs.
+
+\subsection{Use logging functions}
+
+There is a variety of logging functions that you can use in your program:
+see \helpref{Logging functions}{logfunctions}.
+
+Using tracing statements may be more convenient than using the debugger
+in some circumstances (such as when your debugger doesn't support a lot
+of debugging code, or you wish to print a bunch of variables).
+
+\subsection{Use the wxWindows debugging facilities}
+
+You can use wxDebugContext to check for
+memory leaks and corrupt memory: in fact in debugging mode, wxWindows will
+automatically check for memory leaks at the end of the program if wxWindows is suitably
+configured. Depending on the operating system and compiler, more or less
+specific information about the problem will be logged.
+
+You should also use \helpref{debug macros}{debugmacros} as part of a `defensive programming' strategy,
+scattering wxASSERTs liberally to test for problems in your code as early as possible. Forward thinking
+will save a surprising amount of time in the long run.
+
+See the \helpref{debugging overview}{debuggingoverview} for further information.
+
+\subsection{Check Windows debug messages}
+
+Under Windows, it's worth running your program with DBWIN running or
+some other program that shows Windows-generated debug messages. It's
+possible it'll show invalid handles being used. You may have fun seeing
+what commercial programs cause these normally hidden errors! Microsoft
+recommend using the debugging version of Windows, which shows up even
+more problems. However, I doubt it's worth the hassle for most
+applications. wxWindows is designed to minimize the possibility of such
+errors, but they can still happen occasionally, slipping through unnoticed
+because they are not severe enough to cause a crash.
+
+\subsection{Genetic mutation}
+
+If we had sophisticated genetic algorithm tools that could be applied
+to programming, we could use them. Until then, a common -- if rather irrational --
+technique is to just make arbitrary changes to the code until something
+different happens. You may have an intuition why a change will make a difference;
+otherwise, just try altering the order of code, comment lines out, anything
+to get over an impasse. Obviously, this is usually a last resort.
+
+

docs/latex/wx/brush.tex

@@ -0,0 +1,343 @@
+\section{\class{wxBrush}}\label{wxbrush}
+
+A brush is a drawing tool for filling in areas. It is used for painting
+the background of rectangles, ellipses, etc. It has a colour and a
+style.
+
+\wxheading{Derived from}
+
+\helpref{wxGDIObject}{wxgdiobject}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Remarks}
+
+On a monochrome display, wxWindows shows
+all brushes as white unless the colour is really black.
+
+Do not initialize objects on the stack before the program commences,
+since other required structures may not have been set up yet. Instead,
+define global pointers to objects and create them in \helpref{wxApp::OnInit}{wxapponinit} or
+when required.
+
+An application may wish to create brushes with different
+characteristics dynamically, and there is the consequent danger that a
+large number of duplicate brushes will be created. Therefore an
+application may wish to get a pointer to a brush by using the global
+list of brushes {\bf wxTheBrushList}, and calling the member function
+\rtfsp{\bf FindOrCreateBrush}.
+
+wxBrush uses a reference counting system, so assignments between brushes are very
+cheap. You can therefore use actual wxBrush objects instead of pointers without
+efficiency problems. Bear in mind, though, that changing a brush's properties may
+affect another brush which has been involved in an assignment with the first brush,
+because of the way internal brush data is shared.
+
+TODO: an overview for wxBrush.
+
+\wxheading{See also}
+
+\helpref{wxBrushList}{wxbrushlist}, \helpref{wxDC}{wxdc}, \helpref{wxDC::SetBrush}{wxdcsetbrush}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxBrush::wxBrush}
+
+\func{}{wxBrush}{\void}
+
+Default constructor. The brush will be uninitialised, and \helpref{wxBrush::Ok}{wxbrushok} will
+return FALSE.
+
+\func{}{wxBrush}{\param{const wxColour\&}{ colour}, \param{int}{ style}}
+
+Constructs a brush from a colour object and style.
+
+\func{}{wxBrush}{\param{const wxString\& }{colourName}, \param{int}{ style}}
+
+Constructs a brush from a colour name and style.
+
+\func{}{wxBrush}{\param{const wxBitmap\& }{stippleBitmap}}
+
+Constructs a stippled brush using a bitmap.
+
+\func{}{wxBrush}{\param{const wxBrush\&}{ brush}}
+
+Copy constructor. This uses reference counting so is a cheap operation.
+
+\func{}{wxBrush}{\param{const wxBrush*}{ brush}}
+
+Copy constructor. This uses reference counting so is a cheap operation.
+
+\wxheading{Parameters}
+
+\docparam{colour}{Colour object.}
+
+\docparam{colourName}{Colour name. The name will be looked up in the colour database.}
+
+\docparam{style}{One of:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxTRANSPARENT}}{Transparent (no fill).}
+\twocolitem{{\bf wxSOLID}}{Solid.}
+\twocolitem{{\bf wxBDIAGONAL\_HATCH}}{Backward diagonal hatch.}
+\twocolitem{{\bf wxCROSSDIAG\_HATCH}}{Cross-diagonal hatch.}
+\twocolitem{{\bf wxFDIAGONAL\_HATCH}}{Forward diagonal hatch.}
+\twocolitem{{\bf wxCROSS\_HATCH}}{Cross hatch.}
+\twocolitem{{\bf wxHORIZONTAL\_HATCH}}{Horizontal hatch.}
+\twocolitem{{\bf wxVERTICAL\_HATCH}}{Vertical hatch.}
+\end{twocollist}}
+
+\docparam{brush}{Pointer or reference to a brush to copy.}
+
+\docparam{stippleBitmap}{A bitmap to use for stippling.}
+
+\wxheading{Remarks}
+
+If a stipple brush is created, the brush style will be set to wxSTIPPLE.
+
+\wxheading{See also}
+
+\helpref{wxBrushList}{wxbrushlist}, \helpref{wxColour}{wxcolour}, \helpref{wxColourDatabase}{wxcolourdatabase}
+
+\membersection{wxBrush::\destruct{wxBrush}}
+
+\func{void}{\destruct{wxBrush}}{\void}
+
+Destructor.
+
+\wxheading{Remarks}
+
+The destructor may not delete the underlying brush object of the native windowing
+system, since wxBrush uses a reference counting system for efficiency.
+
+Although all remaining brushes are deleted when the application exits,
+the application should try to clean up all brushes itself. This is because
+wxWindows cannot know if a pointer to the brush object is stored in an
+application data structure, and there is a risk of double deletion.
+
+\membersection{wxBrush::GetColour}\label{wxbrushgetcolour}
+
+\constfunc{wxColour\&}{GetColour}{\void}
+
+Returns a reference to the brush colour.
+
+\wxheading{See also}
+
+\helpref{wxBrush::SetColour}{wxbrushsetcolour}
+
+\membersection{wxBrush::GetStipple}\label{wxbrushgetstipple}
+
+\constfunc{wxBitmap *}{GetStipple}{\void}
+
+Gets a pointer to the stipple bitmap. If the brush does not have a wxSTIPPLE style,
+this bitmap may be non-NULL but uninitialised (\helpref{wxBitmap::Ok}{wxbitmapok} returns FALSE).
+
+\wxheading{See also}
+
+\helpref{wxBrush::SetStipple}{wxbrushsetstipple}
+
+\membersection{wxBrush::GetStyle}\label{wxbrushgetstyle}
+
+\constfunc{int}{GetStyle}{\void}
+
+Returns the brush style, one of:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxTRANSPARENT}}{Transparent (no fill).}
+\twocolitem{{\bf wxSOLID}}{Solid.}
+\twocolitem{{\bf wxBDIAGONAL\_HATCH}}{Backward diagonal hatch.}
+\twocolitem{{\bf wxCROSSDIAG\_HATCH}}{Cross-diagonal hatch.}
+\twocolitem{{\bf wxFDIAGONAL\_HATCH}}{Forward diagonal hatch.}
+\twocolitem{{\bf wxCROSS\_HATCH}}{Cross hatch.}
+\twocolitem{{\bf wxHORIZONTAL\_HATCH}}{Horizontal hatch.}
+\twocolitem{{\bf wxVERTICAL\_HATCH}}{Vertical hatch.}
+\twocolitem{{\bf wxSTIPPLE}}{Stippled using a bitmap.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxBrush::SetStyle}{wxbrushsetstyle}, \helpref{wxBrush::SetColour}{wxbrushsetcolour},\rtfsp
+\helpref{wxBrush::SetStipple}{wxbrushsetstipple}
+
+\membersection{wxBrush::Ok}\label{wxbrushok}
+
+\constfunc{bool}{Ok}{\void}
+
+Returns TRUE if the brush is initialised. It will return FALSE if the default
+constructor has been used (for example, the brush is a member of a class, or
+NULL has been assigned to it).
+
+\membersection{wxBrush::SetColour}\label{wxbrushsetcolour}
+
+\func{void}{SetColour}{\param{wxColour\& }{colour}}
+
+Sets the brush colour using a reference to a colour object.
+
+\func{void}{SetColour}{\param{const wxString\& }{colourName}}
+
+Sets the brush colour using a colour name from the colour database.
+
+\func{void}{SetColour}{\param{const unsigned char}{ red}, \param{const unsigned char}{ green}, \param{const unsigned char}{ blue}}
+
+Sets the brush colour using red, green and blue values.
+
+\wxheading{See also}
+
+\helpref{wxBrush::GetColour}{wxbrushgetcolour}
+
+\membersection{wxBrush::SetStipple}\label{wxbrushsetstipple}
+
+\func{void}{SetStipple}{\param{const wxBitmap\&}{ bitmap}}
+
+Sets the stipple bitmap.
+
+\wxheading{Parameters}
+
+\docparam{bitmap}{The bitmap to use for stippling.}
+
+\wxheading{Remarks}
+
+The style will be set to wxSTIPPLE.
+
+Note that there is a big difference between stippling in X and Windows.
+On X, the stipple is a mask between the wxBitmap and current colour.
+On Windows, the current colour is ignored, and the bitmap colour is used.
+However, for pre-defined modes like wxCROSS\_HATCH, the behaviour is the
+same for both platforms.
+
+\wxheading{See also}
+
+\helpref{wxBitmap}{wxbitmap}
+
+\membersection{wxBrush::SetStyle}\label{wxbrushsetstyle}
+
+\func{void}{SetStyle}{\param{int}{ style}}
+
+Sets the brush style.
+
+\docparam{style}{One of:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxTRANSPARENT}}{Transparent (no fill).}
+\twocolitem{{\bf wxSOLID}}{Solid.}
+\twocolitem{{\bf wxBDIAGONAL\_HATCH}}{Backward diagonal hatch.}
+\twocolitem{{\bf wxCROSSDIAG\_HATCH}}{Cross-diagonal hatch.}
+\twocolitem{{\bf wxFDIAGONAL\_HATCH}}{Forward diagonal hatch.}
+\twocolitem{{\bf wxCROSS\_HATCH}}{Cross hatch.}
+\twocolitem{{\bf wxHORIZONTAL\_HATCH}}{Horizontal hatch.}
+\twocolitem{{\bf wxVERTICAL\_HATCH}}{Vertical hatch.}
+\twocolitem{{\bf wxSTIPPLE}}{Stippled using a bitmap.}
+\end{twocollist}}
+
+\wxheading{See also}
+
+\helpref{wxBrush::GetStyle}{wxbrushgetstyle}
+
+\membersection{wxBrush::operator $=$}\label{wxbrushassignment}
+
+\func{wxBrush\&}{operator $=$}{\param{const wxBrush\& }{brush}}
+
+Assignment operator, using reference counting. Returns a reference
+to `this'.
+
+\membersection{wxBrush::operator $==$}\label{wxbrushequals}
+
+\func{bool}{operator $==$}{\param{const wxBrush\& }{brush}}
+
+Equality operator. Two brushes are equal if they contain pointers
+to the same underlying brush data. It does not compare each attribute,
+so two independently-created brushes using the same parameters will
+fail the test.
+
+\membersection{wxBrush::operator $!=$}\label{wxbrushnotequals}
+
+\func{bool}{operator $!=$}{\param{const wxBrush\& }{brush}}
+
+Inequality operator. Two brushes are not equal if they contain pointers
+to different underlying brush data. It does not compare each attribute.
+
+\section{\class{wxBrushList}}\label{wxbrushlist}
+
+A brush list is a list containing all brushes which have been created.
+
+\wxheading{Derived from}
+
+\helpref{wxList}{wxlist}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Remarks}
+
+There is only one instance of this class: {\bf wxTheBrushList}.  Use
+this object to search for a previously created brush of the desired
+type and create it if not already found. In some windowing systems,
+the brush may be a scarce resource, so it can pay to reuse old
+resources if possible. When an application finishes, all brushes will
+be deleted and their resources freed, eliminating the possibility of
+`memory leaks'. However, it is best not to rely on this automatic
+cleanup because it can lead to double deletion in some circumstances.
+
+There are two mechanisms in recent versions of wxWindows which make the
+brush list less useful than it once was. Under Windows, scarce resources
+are cleaned up internally if they are not being used. Also, a referencing
+counting mechanism applied to all GDI objects means that some sharing
+of underlying resources is possible. You don't have to keep track of pointers,
+working out when it is safe delete a brush, because the referencing counting does
+it for you. For example, you can set a brush in a device context, and then
+immediately delete the brush you passed, because the brush is `copied'.
+
+So you may find it easier to ignore the brush list, and instead create
+and copy brushes as you see fit. If your Windows resource meter suggests
+your application is using too many resources, you can resort to using
+GDI lists to share objects explicitly.
+
+The only compelling use for the brush list is for wxWindows to keep
+track of brushes in order to clean them up on exit. It is also kept for
+backward compatibility with earlier versions of wxWindows.
+
+\wxheading{See also}
+
+\helpref{wxBrush}{wxbrush}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxBrushList::wxBrushList}\label{wxbrushlistconstr}
+
+\func{void}{wxBrushList}{\void}
+
+Constructor. The application should not construct its own brush list:
+use the object pointer {\bf wxTheBrushList}.
+
+\membersection{wxBrushList::AddBrush}\label{wxbrushlistaddbrush}
+
+\func{void}{AddBrush}{\param{wxBrush *}{brush}}
+
+Used internally by wxWindows to add a brush to the list.
+
+\membersection{wxBrushList::FindOrCreateBrush}\label{wxbrushlistfindorcreatebrush}
+
+\func{wxBrush *}{FindOrCreateBrush}{\param{const wxColour\& }{colour}, \param{int}{ style}}
+
+Finds a brush with the specified attributes and returns it, else creates a new brush, adds it
+to the brush list, and returns it.
+
+\func{wxBrush *}{FindOrCreateBrush}{\param{const wxString\& }{colourName}, \param{int}{ style}}
+
+Finds a brush with the specified attributes and returns it, else creates a new brush, adds it
+to the brush list, and returns it.
+
+Finds a brush of the given specification, or creates one and adds it to the list.
+
+\wxheading{Parameters}
+
+\docparam{colour}{Colour object.}
+
+\docparam{colourName}{Colour name, which should be in the colour database.}
+
+\docparam{style}{Brush style. See \helpref{wxBrush::SetStyle}{wxbrushsetstyle} for a list of styles.}
+
+\membersection{wxBrushList::RemoveBrush}\label{wxbrushlistremovebrush}
+
+\func{void}{RemoveBrush}{\param{wxBrush *}{brush}}
+
+Used by wxWindows to remove a brush from the list.
+
+

docs/latex/wx/button.tex

@@ -0,0 +1,134 @@
+\section{\class{wxButton}}\label{wxbutton}
+
+A button is a control that contains a text string,
+and is one of the commonest elements of a GUI. It may be placed on a
+\rtfsp\helpref{dialog box}{wxdialog} or \helpref{panel}{wxpanel}, or indeed
+almost any other window.
+
+\wxheading{Derived from}
+
+\helpref{wxControl}{wxcontrol}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Window styles}
+
+There are no special styles for wxButton.
+
+See also \helpref{window styles overview}{windowstyles}.
+
+\wxheading{Event handling}
+
+\twocolwidtha{7cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_BUTTON(id, func)}}{Process a wxEVT\_COMMAND\_BUTTON\_CLICKED event,
+when the button is clicked.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxBitmapButton}{wxbitmapbutton}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxButton::wxButton}\label{wxbuttonconstr}
+
+\func{}{wxButton}{\void}
+
+Default constructor.
+
+\func{}{wxButton}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id}, \param{const wxString\& }{label},\rtfsp
+\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
+
+Constructor, creating and showing a button.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window. Must not be NULL.}
+
+\docparam{id}{Button identifier. A value of -1 indicates a default value.}
+
+\docparam{label}{Text to be displayed on the button.}
+
+\docparam{pos}{Button position.}
+
+\docparam{size}{Button size. If the default size (-1, -1) is specified then the button is sized
+appropriately for the text.}
+
+\docparam{style}{Window style. See \helpref{wxButton}{wxbutton}.}
+
+\docparam{validator}{Window validator.}
+
+\docparam{name}{Window name.}
+
+\wxheading{See also}
+
+\helpref{wxButton::Create}{wxbuttoncreate}, \helpref{wxValidator}{wxvalidator}
+
+\membersection{wxButton::\destruct{wxButton}}
+
+\func{}{\destruct{wxButton}}{\void}
+
+Destructor, destroying the button.
+
+\membersection{wxButton::Create}\label{wxbuttoncreate}
+
+\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id}, \param{const wxString\& }{label},\rtfsp
+\param{const wxPoint\& }{pos}, \param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = 0}, \param{const wxValidator\& }{validator}, \param{const wxString\& }{name = ``button"}}
+
+Button creation function for two-step creation. For more details, see \helpref{wxButton::wxButton}{wxbuttonconstr}.
+
+\membersection{wxButton::GetLabel}\label{wxbuttongetlabel}
+
+\constfunc{wxString}{GetLabel}{\void}
+
+Returns the string label for the button.
+
+\wxheading{Return value}
+
+The button's label.
+
+\wxheading{See also}
+
+\helpref{wxButton::SetLabel}{wxbuttonsetlabel}
+
+\membersection{wxButton::SetDefault}\label{wxbuttonsetdefault}
+
+\func{void}{SetDefault}{\void}
+
+This sets the button to be the default item for the panel or dialog
+box.
+
+\wxheading{Remarks}
+
+Under Windows, only dialog box buttons respond to this function.  As
+normal under Windows and Motif, pressing return causes the default button to
+be depressed when the return key is pressed. See also \helpref{wxWindow::SetFocus}{wxwindowsetfocus}\rtfsp
+which sets the keyboard focus for windows and text panel items,\rtfsp
+and \helpref{wxWindow::GetDefaultItem}{wxwindowgetdefaultitem}.
+
+Note that under Motif, calling this function immediately after
+creation of a button and before the creation of other buttons
+will cause misalignment of the row of buttons, since default
+buttons are larger. To get around this, call {\it SetDefault}\rtfsp
+after you have created a row of buttons: wxWindows will
+then set the size of all buttons currently on the panel to
+the same size.
+
+\membersection{wxButton::SetLabel}\label{wxbuttonsetlabel}
+
+\func{void}{SetLabel}{\param{const wxString\& }{label}}
+
+Sets the string label for the button.
+
+\wxheading{Parameters}
+
+\docparam{label}{The label to set.}
+
+\wxheading{See also}
+
+\helpref{wxButton::GetLabel}{wxbuttongetlabel}
+

docs/latex/wx/calclevt.tex

@@ -0,0 +1,60 @@
+\section{\class{wxCalculateLayoutEvent}}\label{wxcalculatelayoutevent}
+
+This event is sent by \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} to
+calculate the amount of the remaining client area that the window should
+occupy.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+\twocolwidtha{7cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_CALCULATE\_LAYOUT(func)}}{Process a wxEVT\_CALCULATE\_LAYOUT event,
+which asks the window to take a 'bite' out of a rectangle provided by the algorithm.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent},\rtfsp
+\helpref{wxSashLayoutWindow}{wxsashlayoutwindow},\rtfsp
+\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCalculateLayoutEvent::wxCalculateLayoutEvent}
+
+\func{}{wxCalculateLayoutEvent}{\param{wxWindowID }{id = 0}}
+
+Constructor.
+
+\membersection{wxCalculateLayoutEvent::GetFlags}\label{wxcalculatelayouteventgetflags}
+
+\constfunc{int}{GetFlags}{\void}
+
+Returns the flags associated with this event. Not currently used.
+
+\membersection{wxCalculateLayoutEvent::GetRect}\label{wxcalculatelayouteventgetrect}
+
+\constfunc{wxRect}{GetRect}{\void}
+
+Before the event handler is entered, returns the remaining parent client area that the window
+could occupy. When the event handler returns, this should contain the remaining parent client rectangle,
+after the event handler has subtracted the area that its window occupies.
+
+\membersection{wxCalculateLayoutEvent::SetFlags}\label{wxcalculatelayouteventsetflags}
+
+\func{void}{SetFlags}{\param{int }{flags}}
+
+Sets the flags associated with this event. Not currently used.
+
+\membersection{wxCalculateLayoutEvent::SetRect}\label{wxcalculatelayouteventsetrect}
+
+\func{void}{SetRect}{\param{const wxRect\& }{rect}}
+
+Call this to specify the new remaining parent client area, after the space occupied by the
+window has been subtracted.
+

docs/latex/wx/category.tex

@@ -0,0 +1,339 @@
+\chapter{Classes by category}\label{classesbycat}
+\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+
+A classification of wxWindows classes by category.
+\twocolwidtha{5cm}
+
+{\large {\bf Managed windows}}
+
+There are several types of window that are directly controlled by the
+window manager (such as MS Windows, or the Motif Window Manager).
+Frames may contain windows, and dialog boxes may directly contain controls.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxDialog}{wxdialog}}{Dialog box}
+\twocolitem{\helpref{wxFrame}{wxframe}}{Normal frame}
+\twocolitem{\helpref{wxMDIParentFrame}{wxmdiparentframe}}{MDI parent frame}
+\twocolitem{\helpref{wxMDIChildFrame}{wxmdichildframe}}{MDI child frame}
+\twocolitem{\helpref{wxMiniFrame}{wxminiframe}}{A frame with a small title bar}
+\twocolitem{\helpref{wxTabbedDialog}{wxtabbeddialog}}{Tabbed dialog}
+\end{twocollist}
+
+See also {\bf Common dialogs}.
+
+{\large {\bf Miscellaneous windows}}
+
+The following are a variety of windows that are derived from wxWindow.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxGrid}{wxgrid}}{A grid (table) window}
+\twocolitem{\helpref{wxPanel}{wxpanel}}{A window whose colour changes according to current user settings}
+\twocolitem{\helpref{wxSashWindow}{wxsashwindow}}{Window with four optional sashes that can be dragged}
+\twocolitem{\helpref{wxSashLayoutWindow}{wxsashlayoutwindow}}{Window that can be involved in an IDE-like layout arrangement}
+\twocolitem{\helpref{wxScrolledWindow}{wxscrolledwindow}}{Window with automatically managed scrollbars}
+\twocolitem{\helpref{wxSplitterWindow}{wxsplitterwindow}}{Window which can be split vertically or horizontally}
+\twocolitem{\helpref{wxStatusBar}{wxstatusbar}}{Implements the status bar on a frame}
+\twocolitem{\helpref{wxToolBar}{wxtoolbar}}{Toolbar class}
+%\twocolitem{\helpref{wxTabbedPanel}{wxtabbedpanel}}{Tabbed panel (to be replaced with wxNotebook)}
+\twocolitem{\helpref{wxNotebook}{wxnotebook}}{Notebook class}
+\end{twocollist}
+
+{\large {\bf Common dialogs}}
+
+\overview{Overview}{commondialogsoverview}
+
+Common dialogs are ready-made dialog classes which are frequently used
+in an application.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxDialog}{wxdialog}}{Base class for common dialogs}
+\twocolitem{\helpref{wxColourDialog}{wxcolourdialog}}{Colour chooser dialog}
+\twocolitem{\helpref{wxDirDialog}{wxdirdialog}}{Directory selector dialog}
+\twocolitem{\helpref{wxFileDialog}{wxfiledialog}}{File selector dialog}
+\twocolitem{\helpref{wxMultipleChoiceDialog}{wxmultiplechoicedialog}}{Dialog to get one or more selections from a list}
+\twocolitem{\helpref{wxSingleChoiceDialog}{wxsinglechoicedialog}}{Dialog to get a single selection from a list and return the string}
+\twocolitem{\helpref{wxTextEntryDialog}{wxtextentrydialog}}{Dialog to get a single line of text from the user}
+\twocolitem{\helpref{wxFontDialog}{wxfontdialog}}{Font chooser dialog}
+\twocolitem{\helpref{wxPageSetupDialog}{wxpagesetupdialog}}{Standard page setup dialog}
+\twocolitem{\helpref{wxPrintDialog}{wxprintdialog}}{Standard print dialog}
+\twocolitem{\helpref{wxMessageDialog}{wxmessagedialog}}{Simple message box dialog}
+\end{twocollist}
+
+{\large {\bf Controls}}
+
+Typically, these are small windows which provide interaction with the user. Controls
+that are not static can have \helpref{validators}{wxvalidator} associated with them.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxControl}{wxcontrol}}{The base class for controls}
+\twocolitem{\helpref{wxButton}{wxbutton}}{Push button control, displaying text}
+\twocolitem{\helpref{wxBitmapButton}{wxbitmapbutton}}{Push button control, displaying a bitmap}
+\twocolitem{\helpref{wxCheckBox}{wxcheckbox}}{Checkbox control}
+\twocolitem{\helpref{wxCheckListBox}{wxchecklistbox}}{A listbox with a checkbox to the left of each item}
+\twocolitem{\helpref{wxChoice}{wxchoice}}{Choice control (a combobox without the editable area)}
+\twocolitem{\helpref{wxComboBox}{wxcombobox}}{A choice with an editable area}
+\twocolitem{\helpref{wxGauge}{wxgauge}}{A control to represent a varying quantity, such as time remaining}
+\twocolitem{\helpref{wxStaticBox}{wxstaticbox}}{A static, or group box for visually grouping related controls}
+\twocolitem{\helpref{wxListBox}{wxlistbox}}{A list of strings for single or multiple selection}
+\twocolitem{\helpref{wxListCtrl}{wxlistctrl}}{A control for displaying lists of strings and/or icons, plus a multicolumn report view}
+\twocolitem{\helpref{wxTabCtrl}{wxtabctrl}}{Manages several tabs}
+\twocolitem{\helpref{wxTextCtrl}{wxtextctrl}}{Single or multline text editing control}
+\twocolitem{\helpref{wxTreeCtrl}{wxtreectrl}}{Tree (hierachy) control}
+\twocolitem{\helpref{wxScrollBar}{wxscrollbar}}{Scrollbar control}
+\twocolitem{\helpref{wxSpinButton}{wxspinbutton}}{A spin or `up-down' control}
+\twocolitem{\helpref{wxStaticText}{wxstatictext}}{One or more lines of non-editable text}
+\twocolitem{\helpref{wxStaticBitmap}{wxstaticbitmap}}{A control to display a bitmap}
+\twocolitem{\helpref{wxRadioBox}{wxradiobox}}{A group of radio buttons}
+\twocolitem{\helpref{wxRadioButton}{wxradiobutton}}{A round button to be used with others in a mutually exclusive way}
+\twocolitem{\helpref{wxSlider}{wxslider}}{A slider that can be dragged by the user}
+\end{twocollist}
+
+{\large {\bf Menus}}
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxMenu}{wxmenu}}{Displays a series of menu items for selection}
+\twocolitem{\helpref{wxMenuBar}{wxmenubar}}{Contains a series of menus for use with a frame}
+\twocolitem{\helpref{wxMenuItem}{wxmenuitem}}{Represents a single menu item}
+\end{twocollist}
+
+{\large {\bf Window layout}}
+
+\overview{Overview}{constraintsoverview}
+
+These are the classes relevant to automated window layout.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxIndividualLayoutConstraint}{wxindividuallayoutconstraint}}{Represents a single constraint dimension}
+\twocolitem{\helpref{wxLayoutConstraints}{wxlayoutconstraints}}{Represents the constraints for a window class}
+\end{twocollist}
+
+{\large {\bf Device contexts}}
+
+\overview{Overview}{dcoverview}
+
+Device contexts are surfaces that may be drawn on, and provide an
+abstraction that allows parameterisation of your drawing code
+by passing different device contexts.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxClientDC}{wxclientdc}}{A device context to access the client area outside {\bf OnPaint} events}
+\twocolitem{\helpref{wxPaintDC}{wxpaintdc}}{A device context to access the client area inside {\bf OnPaint} events}
+\twocolitem{\helpref{wxWindowDC}{wxwindowdc}}{A device context to access the non-client area}
+\twocolitem{\helpref{wxScreenDC}{wxscreendc}}{A device context to access the entire screen}
+\twocolitem{\helpref{wxDC}{wxdc}}{The device context base class}
+\twocolitem{\helpref{wxMemoryDC}{wxmemorydc}}{A device context for drawing into bitmaps}
+\twocolitem{\helpref{wxMetaFileDC}{wxmetafiledc}}{A device context for drawing into metafiles}
+\twocolitem{\helpref{wxPostScriptDC}{wxpostscriptdc}}{A device context for drawing into PostScript files}
+\twocolitem{\helpref{wxPrinterDC}{wxprinterdc}}{A device context for drawing to printers}
+\end{twocollist}
+
+{\large {\bf Graphics device interface}}
+
+\overview{Bitmaps overview}{wxbitmapoverview}
+
+These classes are related to drawing on device contexts and windows.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxColour}{wxcolour}}{Represents the red, blue and green elements of a colour}
+\twocolitem{\helpref{wxBitmap}{wxbitmap}}{Represents a bitmap}
+\twocolitem{\helpref{wxBrush}{wxbrush}}{Used for filling areas on a device context}
+\twocolitem{\helpref{wxBrushList}{wxbrushlist}}{The list of previously-created brushes}
+\twocolitem{\helpref{wxCursor}{wxcursor}}{A small, transparent bitmap representing the cursor}
+\twocolitem{\helpref{wxFont}{wxfont}}{Represents fonts}
+\twocolitem{\helpref{wxFontList}{wxfontlist}}{The list of previously-created fonts}
+\twocolitem{\helpref{wxIcon}{wxicon}}{A small, transparent bitmap for assigning to frames and drawing on device contexts}
+\twocolitem{\helpref{wxImageList}{wximagelist}}{A list of images, used with some controls}
+\twocolitem{\helpref{wxMask}{wxmask}}{Represents a mask to be used with a bitmap for transparent drawing}
+\twocolitem{\helpref{wxPen}{wxpen}}{Used for drawing lines on a device context}
+\twocolitem{\helpref{wxPenList}{wxpenlist}}{The list of previously-created pens}
+\twocolitem{\helpref{wxPalette}{wxpalette}}{Represents a table of indices into RGB values}
+\twocolitem{\helpref{wxRegion}{wxregion}}{Represents a simple or complex region on a window or device context}
+\end{twocollist}
+
+{\large {\bf Events}}
+
+\overview{Overview}{eventhandlingoverview}
+
+An event object contains information about a specific event. Event handlers
+(usually member functions) have a single, event argument.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxActivateEvent}{wxactivateevent}}{A window or application activation event}
+\twocolitem{\helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent}}{Used to calculate window layout}
+\twocolitem{\helpref{wxCloseEvent}{wxcloseevent}}{A close window or end session event}
+\twocolitem{\helpref{wxCommandEvent}{wxcommandevent}}{An event from a variety of standard controls}
+\twocolitem{\helpref{wxDropFilesEvent}{wxdropfilesevent}}{A drop files event}
+\twocolitem{\helpref{wxEraseEvent}{wxeraseevent}}{An erase background event}
+\twocolitem{\helpref{wxEvent}{wxevent}}{The event base class}
+\twocolitem{\helpref{wxFocusEvent}{wxfocusevent}}{A window focus event}
+\twocolitem{\helpref{wxKeyEvent}{wxkeyevent}}{A keypress event}
+\twocolitem{\helpref{wxIdleEvent}{wxidleevent}}{An idle event}
+\twocolitem{\helpref{wxInitDialogEvent}{wxinitdialogevent}}{A dialog initialisation event}
+\twocolitem{\helpref{wxJoystickEvent}{wxjoystickevent}}{A joystick event}
+\twocolitem{\helpref{wxListEvent}{wxlistevent}}{A list control event}
+\twocolitem{\helpref{wxMenuEvent}{wxmenuevent}}{A menu event}
+\twocolitem{\helpref{wxMouseEvent}{wxmouseevent}}{A mouse event}
+\twocolitem{\helpref{wxMoveEvent}{wxmoveevent}}{A move event}
+\twocolitem{\helpref{wxNotebookEvent}{wxnotebookevent}}{A notebook control event}
+\twocolitem{\helpref{wxPaintEvent}{wxpaintevent}}{A paint event}
+\twocolitem{\helpref{wxProcessEvent}{wxprocessevent}}{A process ending event}
+\twocolitem{\helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent}}{Used to query layout information}
+\twocolitem{\helpref{wxSizeEvent}{wxsizeevent}}{A size event}
+\twocolitem{\helpref{wxSocketEvent}{wxsocketevent}}{A socket event}
+\twocolitem{\helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}}{A system colour change event}
+\twocolitem{\helpref{wxTabEvent}{wxtabevent}}{A tab control event}
+\twocolitem{\helpref{wxTreeEvent}{wxtreeevent}}{A tree control event}
+\twocolitem{\helpref{wxUpdateUIEvent}{wxupdateuievent}}{A user interface update event}
+\end{twocollist}
+
+{\large {\bf Validators}}
+
+\overview{Overview}{validatoroverview}
+
+These are the window validators, used for filtering and validating
+user input.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxValidator}{wxvalidator}}{Base validator class.}
+\twocolitem{\helpref{wxTextValidator}{wxtextvalidator}}{Text control validator class.}
+\end{twocollist}
+
+{\large {\bf Data structures}}
+
+These are the data structure classes supported by wxWindows.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxExpr}{wxexpr}}{A class for flexible I/O}
+\twocolitem{\helpref{wxExprDatabase}{wxexprdatabase}}{A class for flexible I/O}
+\twocolitem{\helpref{wxDate}{wxdate}}{A class for date manipulation}
+\twocolitem{\helpref{wxHashTable}{wxhashtable}}{A simple hash table implementation}
+\twocolitem{\helpref{wxList}{wxlist}}{A simple linked list implementation}
+\twocolitem{\helpref{wxNode}{wxnode}}{Represents a node in the wxList implementation}
+\twocolitem{\helpref{wxObject}{wxobject}}{The root class for most wxWindows classes}
+\twocolitem{\helpref{wxPathList}{wxpathlist}}{A class to help search multiple paths}
+\twocolitem{\helpref{wxPoint}{wxpoint}}{Representation of a point}
+\twocolitem{\helpref{wxRect}{wxrect}}{A class representing a rectangle}
+\twocolitem{\helpref{wxRegion}{wxregion}}{A class representing a region}
+\twocolitem{\helpref{wxString}{wxstring}}{A string class}
+\twocolitem{\helpref{wxStringList}{wxstringlist}}{A class representing a list of strings}
+\twocolitem{\helpref{wxRealPoint}{wxrealpoint}}{Representation of a point using floating point numbers}
+\twocolitem{\helpref{wxSize}{wxsize}}{Representation of a size}
+\twocolitem{\helpref{wxTime}{wxtime}}{A class for time manipulation}
+\end{twocollist}
+
+{\large {\bf Run-time class information system}}
+
+\overview{Overview}{runtimeclassoverview}
+
+wxWindows supports run-time manipulation of class information, and dynamic
+creation of objects given class names.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxClassInfo}{wxclassinfo}}{Holds run-time class information}
+\twocolitem{\helpref{wxObject}{wxobject}}{Root class for classes with run-time information}
+\twocolitem{\helpref{Macros}{macros}}{Macros for manipulating run-time information}
+\end{twocollist}
+
+{\large {\bf Debugging features}}
+
+\overview{Overview}{debuggingoverview}
+
+wxWindows supports some aspects of debugging an application through
+classes, functions and macros.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxDebugContext}{wxdebugcontext}}{Provides memory-checking facilities}
+%\twocolitem{\helpref{wxDebugStreamBuf}{wxdebugstreambuf}}{A stream buffer writing to the debug stream}
+\twocolitem{\helpref{wxLog}{wxlog}}{Logging facility}
+\twocolitem{\helpref{Log functions}{logfunctions}}{Error and warning logging functions}
+\twocolitem{\helpref{Debugging macros}{debugmacros}}{Debug macros for assertion and checking}
+%\twocolitem{\helpref{wxTrace}{wxtrace}}{Tracing facility}
+%\twocolitem{\helpref{wxTraceLevel}{wxtracelevel}}{Tracing facility with levels}
+\twocolitem{\helpref{WXDEBUG\_NEW}{debugnew}}{Use this macro to give further debugging information}
+%\twocolitem{\helpref{WXTRACE}{trace}}{Trace macro}
+%\twocolitem{\helpref{WXTRACELEVEL}{tracelevel}}{Trace macro with levels}
+\end{twocollist}
+
+{\large {\bf Interprocess communication}}
+
+\overview{Overview}{ipcoverview}
+
+wxWindows provides a simple interprocess communications facilities
+based on DDE.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxDDEClient}{wxddeclient}}{Represents a client}
+\twocolitem{\helpref{wxDDEConnection}{wxddeconnection}}{Represents the connection between a client and a server}
+\twocolitem{\helpref{wxDDEServer}{wxddeserver}}{Represents a server}
+\twocolitem{\helpref{wxSocketClient}{wxsocketclient}}{Represents a socket client}
+\twocolitem{\helpref{wxSocketHandler}{wxsockethandler}}{Represents a socket handler}
+\twocolitem{\helpref{wxSocketServer}{wxsocketserver}}{Represents a socket server}
+\end{twocollist}
+
+{\large {\bf Document/view framework}}
+
+\overview{Overview}{docviewoverview}
+
+wxWindows supports a document/view framework which provides
+housekeeping for a document-centric application.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxDocument}{wxdocument}}{Represents a document}
+\twocolitem{\helpref{wxView}{wxview}}{Represents a view}
+\twocolitem{\helpref{wxDocTemplate}{wxdoctemplate}}{Manages the relationship between a document class and a veiw class}
+\twocolitem{\helpref{wxDocManager}{wxdocmanager}}{Manages the documents and views in an application}
+\twocolitem{\helpref{wxDocChildFrame}{wxdocchildframe}}{A child frame for showing a document view}
+\twocolitem{\helpref{wxDocParentFrame}{wxdocparentframe}}{A parent frame to contain views}
+%\twocolitem{\helpref{wxMDIDocChildFrame}{wxmdidocchildframe}}{An MDI child frame for showing a document view}
+%\twocolitem{\helpref{wxMDIDocParentFrame}{wxmdidocparentframe}}{An MDI parent frame to contain views}
+\end{twocollist}
+
+{\large {\bf Printing framework}}
+
+\overview{Overview}{printingoverview}
+
+A printing and previewing framework is implemented to
+make it relatively straighforward to provide document printing
+facilities.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxPreviewFrame}{wxpreviewframe}}{Frame for displaying a print preview}
+\twocolitem{\helpref{wxPreviewCanvas}{wxpreviewcanvas}}{Canvas for displaying a print preview}
+\twocolitem{\helpref{wxPreviewControlBar}{wxpreviewcontrolbar}}{Standard control bar for a print preview}
+\twocolitem{\helpref{wxPrintData}{wxprintdata}}{Represents information about the document being printed}
+\twocolitem{\helpref{wxPrintDialog}{wxprintdialog}}{Standard print dialog}
+\twocolitem{\helpref{wxPrinter}{wxprinter}}{Class representing the printer}
+\twocolitem{\helpref{wxPrinterDC}{wxprinterdc}}{Printer device context}
+\twocolitem{\helpref{wxPrintout}{wxprintout}}{Class representing a particular printout}
+\twocolitem{\helpref{wxPrintPreview}{wxprintpreview}}{Class representing a print preview}
+\end{twocollist}
+
+{\large {\bf Database classes}}
+
+\overview{Database classes overview}{odbcoverview}
+
+wxWindows provides a set of classes for accessing Microsoft's ODBC (Open Database Connectivity)
+product.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxDatabase}{wxdatabase}}{Database class}
+\twocolitem{\helpref{wxQueryCol}{wxquerycol}}{Class representing a column}
+\twocolitem{\helpref{wxQueryField}{wxqueryfield}}{Class representing a field}
+\twocolitem{\helpref{wxRecordSet}{wxrecordset}}{Class representing one or more record}
+\end{twocollist}
+
+{\large {\bf Miscellaneous}}
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\helpref{wxAcceleratorTable}{wxacceleratortable}}{Accelerator table}
+\twocolitem{\helpref{wxApp}{wxapp}}{Application class}
+\twocolitem{\helpref{wxConfig}{wxconfigbase}}{Classes for configuration reading/writing}
+\twocolitem{\helpref{wxHelpController}{wxhelpcontroller}}{Family of classes for controlling help windows}
+\twocolitem{\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}}{An alternative window layout facility}
+\twocolitem{\helpref{wxProcess}{wxprocess}}{Process class}
+\twocolitem{\helpref{wxTimer}{wxtimer}}{Timer class}
+\twocolitem{\helpref{wxSystemSettings}{wxsystemsettings}}{System settings class}
+\end{twocollist}
+
+

docs/latex/wx/checkbox.tex

@@ -0,0 +1,104 @@
+\section{\class{wxCheckBox}}\label{wxcheckbox}
+
+A checkbox is a labelled box which is either on (checkmark is visible)
+or off (no checkmark).
+
+\wxheading{Derived from}
+
+\helpref{wxControl}{wxcontrol}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Window styles}
+
+There are no special styles for wxCheckBox.
+
+See also \helpref{window styles overview}{windowstyles}.
+
+\wxheading{Event handling}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_CHECKBOX(id, func)}}{Process a wxEVT\_COMMAND\_CHECKBOX\_CLICKED event,
+when the checkbox is clicked.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxRadioButton}{wxradiobutton}, \helpref{wxCommandEvent}{wxcommandevent}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCheckBox::wxCheckBox}\label{wxcheckboxconstr}
+
+\func{}{wxCheckBox}{\void}
+
+Default constructor.
+
+\func{}{wxCheckBox}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id},\rtfsp
+\param{const wxString\& }{label}, \param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
+\param{const wxSize\& }{size = wxDefaultSize}, \param{long}{ style = 0},\rtfsp
+\param{const wxValidator\& }{val}, \param{const wxString\& }{name = ``checkBox"}}
+
+Constructor, creating and showing a checkbox.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window. Must not be NULL.}
+
+\docparam{id}{Checkbox identifier. A value of -1 indicates a default value.}
+
+\docparam{label}{Text to be displayed next to the checkbox.}
+
+\docparam{pos}{Checkbox position. If the position (-1, -1) is specified then a default position is chosen.}
+
+\docparam{size}{Checkbox size. If the default size (-1, -1) is specified then a default size is chosen.}
+
+\docparam{style}{Window style. See \helpref{wxCheckBox}{wxcheckbox}.}
+
+\docparam{validator}{Window validator.}
+
+\docparam{name}{Window name.}
+
+\wxheading{See also}
+
+\helpref{wxCheckBox::Create}{wxcheckboxcreate}, \helpref{wxValidator}{wxvalidator}
+
+\membersection{wxCheckBox::\destruct{wxCheckBox}}
+
+\func{}{\destruct{wxCheckBox}}{\void}
+
+Destructor, destroying the checkbox.
+
+\membersection{wxCheckBox::Create}\label{wxcheckboxcreate}
+
+\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID}{ id},\rtfsp
+\param{const wxString\& }{label}, \param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
+\param{const wxSize\& }{size = wxDefaultSize}, \param{long}{ style = 0},\rtfsp
+\param{const wxValidator\& }{val}, \param{const wxString\& }{name = ``checkBox"}}
+
+Creates the checkbox for two-step construction. See \helpref{wxCheckBox::wxCheckBox}{wxcheckboxconstr}\rtfsp
+for details.
+
+\membersection{wxCheckBox::GetValue}\label{wxcheckboxgetvalue}
+
+\constfunc{bool}{GetValue}{\void}
+
+Gets the state of the checkbox.
+
+\wxheading{Return value}
+
+Returns TRUE if it is checked, FALSE otherwise.
+
+\membersection{wxCheckBox::SetValue}\label{wxcheckboxsetvalue}
+
+\func{void}{SetValue}{\param{const bool}{ state}}
+
+Sets the checkbox to the given state.
+
+\wxheading{Parameters}
+
+\docparam{state}{If TRUE, the check is on, otherwise it is off.}
+
+

docs/latex/wx/checklst.tex

@@ -0,0 +1,95 @@
+\section{\class{wxCheckListBox}}\label{wxchecklistbox}
+
+A checklistbox is like a listbox, but allows items to be checked or unchecked.
+
+This class is currently only implemented under Windows, and wxWindows must be
+compiled with USE\_OWNER\_DRAWN set to 1.
+
+Only the new functions for this class are documented; see also \helpref{wxListBox}{wxlistbox}.
+
+\wxheading{Derived from}
+
+\helpref{wxListBox}{wxlistbox}\\
+\helpref{wxControl}{wxcontrol}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Window styles}
+
+See \helpref{wxListBox}{wxlistbox}.
+
+\wxheading{Event handling}
+
+See \helpref{wxListBox}{wxlistbox}.
+
+\wxheading{See also}
+
+\helpref{wxListBox}{wxlistbox}, \helpref{wxChoice}{wxchoice}, \helpref{wxComboBox}{wxcombobox}, \helpref{wxListCtrl}{wxlistctrl},
+\rtfsp\helpref{wxCommandEvent}{wxcommandevent}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCheckListBox::wxCheckListBox}\label{wxchecklistboxconstr}
+
+\func{}{wxCheckListBox}{\void}
+
+Default constructor.
+
+\func{}{wxCheckListBox}{\param{wxWindow*}{ parent}, \param{wxWindowID}{ id},\rtfsp
+\param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
+\param{int}{ n}, \param{const wxString }{choices[] = NULL},\rtfsp
+\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``listBox"}}
+
+Constructor, creating and showing a list box.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window. Must not be NULL.}
+
+\docparam{id}{Window identifier. A value of -1 indicates a default value.}
+
+\docparam{pos}{Window position.}
+
+\docparam{size}{Window size. If the default size (-1, -1) is specified then the window is sized
+appropriately.}
+
+\docparam{n}{Number of strings with which to initialise the control.}
+
+\docparam{choices}{An array of strings with which to initialise the control.}
+
+\docparam{style}{Window style. See \helpref{wxCheckListBox}{wxchecklistbox}.}
+
+\docparam{validator}{Window validator.}
+
+\docparam{name}{Window name.}
+
+\membersection{wxCheckListBox::\destruct{wxCheckListBox}}
+
+\func{void}{\destruct{wxCheckListBox}}{\void}
+
+Destructor, destroying the list box.
+
+\membersection{wxCheckListBox::Check}\label{wxchecklistboxcheck}
+
+\func{void}{Check}{\param{int }{item}, \param{bool}{ check = TRUE}}
+
+Checks the given item.
+
+\wxheading{Parameters}
+
+\docparam{item}{Index of item to check.}
+
+\docparam{check}{TRUE if the item is to be checked, FALSE otherwise.}
+
+\membersection{wxCheckListBox::IsChecked}\label{wxchecklistboxischecked}
+
+\constfunc{bool}{IsChecked}{\param{int}{ item}}
+
+Returns TRUE if the given item is checked, FALSE otherwise.
+
+\wxheading{Parameters}
+
+\docparam{item}{Index of item whose check status is to be returned.}
+
+

docs/latex/wx/choice.tex

@@ -0,0 +1,202 @@
+\section{\class{wxChoice}}\label{wxchoice}
+
+A choice item is used to select one of a list of strings. Unlike a
+listbox, only the selection is visible until the user pulls down the
+menu of choices.
+
+\wxheading{Derived from}
+
+\helpref{wxControl}{wxcontrol}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Window styles}
+
+There are no special styles for wxChoice.
+
+See also \helpref{window styles overview}{windowstyles}.
+
+\wxheading{Event handling}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_CHOICE(id, func)}}{Process a wxEVT\_COMMAND\_CHOICE\_SELECTED event,
+when an item on the list is selected.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxListBox}{wxlistbox}, \helpref{wxComboBox}{wxcombobox},
+\rtfsp\helpref{wxCommandEvent}{wxcommandevent}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxChoice::wxChoice}\label{wxchoiceconstr}
+
+\func{}{wxChoice}{\void}
+
+Default constructor.
+
+\func{}{wxChoice}{\param{wxWindow *}{parent}, \param{wxWindowID}{ id},\rtfsp
+\param{const wxPoint\& }{pos}, \param{const wxSize\&}{ size},\rtfsp
+\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
+\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``choice"}}
+
+Constructor, creating and showing a choice.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window. Must not be NULL.}
+
+\docparam{id}{Window identifier. A value of -1 indicates a default value.}
+
+\docparam{pos}{Window position.}
+
+\docparam{size}{Window size. If the default size (-1, -1) is specified then the choice is sized
+appropriately.}
+
+\docparam{n}{Number of strings with which to initialise the choice control.}
+
+\docparam{choices}{An array of strings with which to initialise the choice control.}
+
+\docparam{style}{Window style. See \helpref{wxChoice}{wxchoice}.}
+
+\docparam{validator}{Window validator.}
+
+\docparam{name}{Window name.}
+
+\wxheading{See also}
+
+\helpref{wxChoice::Create}{wxchoicecreate}, \helpref{wxValidator}{wxvalidator}
+
+\membersection{wxChoice::\destruct{wxChoice}}
+
+\func{}{\destruct{wxChoice}}{\void}
+
+Destructor, destroying the choice item.
+
+\membersection{wxChoice::Append}\label{wxchoiceappend}
+
+\func{void}{Append}{\param{const wxString\& }{ item}}
+
+Adds the item to the end of the choice control.
+
+\wxheading{Parameters}
+
+\docparam{item}{String to add.}
+
+\membersection{wxChoice::Clear}\label{wxchoiceclear}
+
+\func{void}{Clear}{\void}
+
+Clears the strings from the choice item.
+
+\membersection{wxChoice::Create}\label{wxchoicecreate}
+
+\func{bool}{Create}{\param{wxWindow *}{parent}, \param{wxWindowID}{ id},\rtfsp
+\param{const wxPoint\& }{pos}, \param{const wxSize\&}{ size},\rtfsp
+\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
+\param{long}{ style = 0}, \param{const wxString\& }{name = ``choice"}}
+
+Creates the choice for two-step construction. See \helpref{wxChoice::wxChoice}{wxchoiceconstr}.
+
+\membersection{wxChoice::FindString}\label{wxchoicefindstring}
+
+\constfunc{int}{FindString}{\param{const wxString\& }{string}}
+
+Finds a choice matching the given string.
+
+\wxheading{Parameters}
+
+\docparam{string}{String to find.}
+
+\wxheading{Return value}
+
+Returns the position if found, or -1 if not found.
+
+\membersection{wxChoice::GetColumns}\label{wxchoicegetcolumns}
+
+\constfunc{int}{GetColumns}{\void}
+
+Gets the number of columns in this choice item.
+
+\wxheading{Remarks}
+
+This is implemented for Motif only.
+
+\membersection{wxChoice::GetSelection}\label{wxchoicegetselection}
+
+\constfunc{int}{GetSelection}{\void}
+
+Gets the id (position) of the selected string, or -1 if there is no selection.
+
+\membersection{wxChoice::GetString}\label{wxchoicegetstring}
+
+\constfunc{wxString}{GetString}{\param{int}{ n}}
+
+Returns the string at the given position.
+
+\wxheading{Parameters}
+
+\docparam{n}{The zero-based position.}
+
+\wxheading{Return value}
+
+The string at the given position, or the empty string if {\it n} is invalid.
+
+\membersection{wxChoice::GetStringSelection}\label{wxchoicegetstringselection}
+
+\constfunc{wxString}{GetStringSelection}{\void}
+
+Gets the selected string, or the empty string if no string is selected.
+
+\membersection{wxChoice::Number}\label{wxchoicenumber}
+
+\constfunc{int}{Number}{\void}
+
+Returns the number of strings in the choice control.
+
+\membersection{wxChoice::SetColumns}\label{wxchoicesetcolumns}
+
+\func{void}{SetColumns}{\param{int}{ n = 1}}
+
+Sets the number of columns in this choice item.
+
+\wxheading{Parameters}
+
+\docparam{n}{Number of columns.}
+
+\wxheading{Remarks}
+
+This is implemented for Motif only.
+
+\membersection{wxChoice::SetSelection}\label{wxchoicesetselection}
+
+\func{void}{SetSelection}{\param{int}{ n}}
+
+Sets the choice by passing the desired string position.
+
+\wxheading{Parameters}
+
+\docparam{n}{The string position to select, starting from zero.}
+
+\wxheading{See also}
+
+\helpref{wxChoice::SetStringSelection}{wxchoicesetstringselection}
+
+\membersection{wxChoice::SetStringSelection}\label{wxchoicesetstringselection}
+
+\func{void}{SetStringSelection}{\param{const wxString\& }{ string}}
+
+Sets the choice by passing the desired string.
+
+\wxheading{Parameters}
+
+\docparam{string}{The string to select.}
+
+\wxheading{See also}
+
+\helpref{wxChoice::SetSelection}{wxchoicesetselection}
+
+

docs/latex/wx/clasinfo.tex

@@ -0,0 +1,75 @@
+\section{\class{wxClassInfo}}\label{wxclassinfo}
+
+This class stores meta-information about classes. Instances of this class are
+not generally defined directly by an application, but indirectly through use
+of macros such as {\bf DECLARE\_DYNAMIC\_CLASS} and {\bf IMPLEMENT\_DYNAMIC\_CLASS}.
+
+\wxheading{Derived from}
+
+No parent class.
+
+\wxheading{See also}
+
+\helpref{Overview}{wxclassinfooverview}, \helpref{wxObject}{wxobject}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxClassInfo::wxClassInfo}\label{wxclassinfoconstr}
+
+\func{}{wxClassInfo}{\param{char* }{className}, \param{char* }{baseClass1}, \param{char* }{baseClass2},
+ \param{int}{ size}, \param{wxObjectConstructorFn }{fn}}
+
+Constructs a wxClassInfo object. The supplied macros implicitly construct objects of this
+class, so there is no need to create such objects explicitly in an application.
+
+\membersection{wxClassInfo::CreateObject}
+
+\func{wxObject*}{CreateObject}{\void}
+
+Creates an object of the appropriate kind. Returns NULL if the class has not been declared
+dynamically createable (typically, it's an abstract class).
+
+\membersection{wxClassInfo::FindClass}
+
+\func{static wxClassInfo *}{FindClass}{\param{char* }{name}}
+
+Finds the wxClassInfo object for a class of the given string name.
+
+\membersection{wxClassInfo::GetBaseClassName1}
+
+\constfunc{char*}{GetBaseClassName1}{\void}
+
+Returns the name of the first base class (NULL if none).
+
+\membersection{wxClassInfo::GetBaseClassName2}
+
+\constfunc{char*}{GetBaseClassName2}{\void}
+
+Returns the name of the second base class (NULL if none).
+
+\membersection{wxClassInfo::GetClassName}
+
+\constfunc{char *}{GetClassName}{\void}
+
+Returns the string form of the class name.
+
+\membersection{wxClassInfo::GetSize}
+
+\constfunc{int}{GetSize}{\void}
+
+Returns the size of the class.
+
+\membersection{wxClassInfo::InitializeClasses}
+
+\func{static void}{InitializeClasses}{\void}
+
+Initializes pointers in the wxClassInfo objects for fast execution
+of IsKindOf. Called in base wxWindows library initialization.
+
+\membersection{wxClassInfo::IsKindOf}\label{wxclassinfoiskindof}
+
+\func{bool}{IsKindOf}{\param{wxClassInfo* }{info}}
+
+Returns TRUE if this class is a kind of (inherits from) the given class.
+
+

docs/latex/wx/classes.tex

@@ -0,0 +1,196 @@
+\chapter{Alphabetical class reference}\label{classref}
+\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
+\setfooter{\thepage}{}{}{}{}{\thepage}%
+\pagenumbering{arabic}%
+%
+\begin{comment}
+\helpignore{\section{Class hierarchy}%
+
+The GUI-specific wxWindows class hierarchy is shown in Figure 5.1.
+Many other, non-GUI classes have been omitted.
+
+\vskip 1cm
+$$\image{14cm;0cm}{wxclass.ps}$$
+\vskip 1cm
+\centerline{Figure 5.1: wxWindows class hierarchy}
+
+\newpage}%
+
+\overview{Writing a wxWindows application: a rough guide}{roughguide}
+
+\helponly{
+\sethotspotcolour{off}%
+\large{
+\helpref{Notes on using the reference}{referencenotes}\\
+\helpref{Guide to functions}{functions}
+\sethotspotcolour{on}%
+}}
+\end{comment}
+
+\input accel.tex
+\input activevt.tex
+\input app.tex
+\input button.tex
+\input bitmap.tex
+\input bbutton.tex
+\input brush.tex
+\input calclevt.tex
+\input checkbox.tex
+\input checklst.tex
+\input choice.tex
+\input clasinfo.tex
+\input clientdc.tex
+\input clipbrd.tex
+\input closeevt.tex
+\input colour.tex
+\input colordlg.tex
+\input combobox.tex
+\input command.tex
+\input cmdevent.tex
+\input cmdproc.tex
+\input conditn.tex
+\input config.tex
+\input control.tex
+\input cursor.tex
+\input database.tex
+\input date.tex
+\input datstrm.tex
+\input dc.tex
+\input ddeclint.tex
+\input ddeconn.tex
+\input ddeservr.tex
+\input debugcxt.tex
+\input dialog.tex
+\input dirdlg.tex
+\input document.tex
+\input docchfrm.tex
+\input docmanag.tex
+\input docmdich.tex
+\input docmdipr.tex
+\input docprfrm.tex
+\input doctempl.tex
+\input dropevt.tex
+\input eraseevt.tex
+\input event.tex
+\input evthand.tex
+\input expr.tex
+\input file.tex
+\input filedlg.tex
+\input filehist.tex
+\input focusevt.tex
+\input font.tex
+\input fontdlg.tex
+\input fontlist.tex
+\input frame.tex
+\input gauge.tex
+\input gdiobj.tex
+\input grid.tex
+\input hash.tex
+\input helpinst.tex
+\input idleevt.tex
+\input icon.tex
+\input imaglist.tex
+\input ilayout.tex
+\input indlgevt.tex
+\input joystick.tex
+\input joyevent.tex
+\input keyevent.tex
+\input layalgor.tex
+\input layout.tex
+\input list.tex
+\input listbox.tex
+\input listctrl.tex
+\input listevt.tex
+\input log.tex
+\input mask.tex
+\input mdi.tex
+\input menu.tex
+\input menuitem.tex
+\input menuevt.tex
+\input memorydc.tex
+\input msgdlg.tex
+\input metafile.tex
+\input minifram.tex
+\input module.tex
+\input mouseevt.tex
+\input moveevt.tex
+\input mltchdlg.tex
+\input mutex.tex
+\input node.tex
+\input notebook.tex
+\input noteevt.tex
+\input object.tex
+\input pagedlg.tex
+\input paintdc.tex
+\input paintevt.tex
+\input palette.tex
+\input panel.tex
+\input pantabv.tex
+\input pathlist.tex
+\input pen.tex
+\input point.tex
+\input postscpt.tex
+\input prevwin.tex
+\input print.tex
+\input process.tex
+\input procevt.tex
+\input query.tex
+\input qylayevt.tex
+\input radiobox.tex
+\input radiobut.tex
+\input realpoin.tex
+\input rect.tex
+\input recrdset.tex
+\input region.tex
+\input sashevt.tex
+\input sashlayw.tex
+\input sashwin.tex
+\input screendc.tex
+\input scrolbar.tex
+\input scrolevt.tex
+\input scrolwin.tex
+\input sngchdlg.tex
+\input size.tex
+\input sizeevt.tex
+\input slider.tex
+\input sckaddr.tex
+\input socket.tex
+\input spinbutt.tex
+\input splitter.tex
+\input statbmp.tex
+\input statbox.tex
+\input stattext.tex
+\input statusbr.tex
+\input wxstring.tex
+\input strlist.tex
+\input sysclevt.tex
+\input settings.tex
+\input tab.tex
+\input tabctrl.tex
+\input tabevent.tex
+\input taskbar.tex
+\input text.tex
+\input textdlg.tex
+\input valtext.tex
+\input thread.tex
+\input time.tex
+\input timer.tex
+\input toolbar.tex
+\input treectrl.tex
+\input treeevt.tex
+\input upduievt.tex
+\input url.tex
+\input validatr.tex
+\input view.tex
+\input wave.tex
+\input window.tex
+\input windowdc.tex
+
+\input function.tex
+\input keycode.tex
+
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "referenc"
+%%% End: 

docs/latex/wx/clientdc.tex

@@ -0,0 +1,31 @@
+\section{\class{wxClientDC}}\label{wxclientdc}
+
+A wxClientDC must be constructed if an application wishes to paint on the
+client area of a window from outside an {\bf OnPaint} event.
+This should normally be constructed as a temporary stack object; don't store
+a wxClientDC object.
+
+To draw on a window from within {\bf OnPaint}, construct a \helpref{wxPaintDC}{wxpaintdc} object.
+
+To draw on the whole window including decorations, construct a \helpref{wxWindowDC}{wxwindowdc} object
+(Windows only).
+
+\wxheading{Derived from}
+
+\helpref{wxDC}{wxdc}
+
+\wxheading{See also}
+
+\helpref{wxDC}{wxdc}, \helpref{wxMemoryDC}{wxmemorydc}, \helpref{wxPaintDC}{wxpaintdc},\rtfsp
+\helpref{wxWindowDC}{wxwindowdc}, \helpref{wxScreenDC}{wxscreendc}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxClientDC::wxClientDC}
+
+\func{}{wxClientDC}{\param{wxWindow*}{ window}}
+
+Constructor. Pass a pointer to the window on which you wish to paint.
+
+
+

docs/latex/wx/clipbrd.tex

@@ -0,0 +1,103 @@
+\section{\class{wxClipboard}}\label{wxclipboard}
+
+There is one wxClipboard object referenced by the pointer
+wxTheClipboard, initialized by calling \helpref{wxInitClipboard}{wxinitclipboard}.
+Under X, clipboard manipulation must be done by using this class, and
+such code will work under MS Windows also. Under MS Windows, you have the
+alternative of using the normal clipboard functions.
+
+The documentation for this class will be expanded in due course. At present,
+wxClipboard is only used in the wxMediaWindow add-on library.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxClipboardClient}{wxclipboardclient}, \helpref{wxInitClipboard}{wxinitclipboard}.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxClipboard::GetClipboardClient}
+
+\func{wxClipboardClient *}{GetClipboardClient}{\void}
+
+Get the clipboard client directly. Will be NULL if clipboard data
+is a string, or if some other application owns the clipboard. 
+This can be useful for shortcutting data translation, if the
+clipboard user can check for a specific client.
+
+\membersection{wxClipboard::GetClipboardData}
+
+\func{char*}{GetClipboardData}{\param{const wxString\& }{format}, \param{long *}{length}, \param{long}{ time}}
+
+Get data from the clipboard.
+
+\membersection{wxClipboard::GetClipboardString}
+
+\func{wxString}{GetClipboardString}{\param{long}{ time}}
+
+Get the data from the clipboard in the format ``TEXT".
+
+\membersection{wxClipboard::SetClipboardClient}
+
+\func{void}{SetClipboardClient}{\param{wxClipboardClient *}{client}, \param{long}{ time}}
+
+Set the clipboard data owner.
+
+\membersection{wxClipboard::SetClipboardString}
+
+\func{void}{SetClipboardString}{\param{const wxString\& }{data}, \param{long}{ time}}
+
+Set the clipboard string; does not require a client.
+
+\section{\class{wxClipboardClient}}\label{wxclipboardclient}
+
+Implemented under X and MS Windows, a clipboard client holds data
+belonging to the clipboard. For plain text, a client is not necessary.
+
+wxClipboardClient is an abstract class for which the virtual functions
+BeingReplaced and GetData must be overridden.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxClipboard}{wxclipboard}, \helpref{wxInitClipboard}{wxinitclipboard}.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxClipboardClient::formats}
+
+\member{wxStringList}{formats}
+
+This list should be filled in with strings indicating the formats
+this client can provide. Almost all clients will provide``TEXT".
+Format names should be 4 characters long, so things will work
+out on the Macintosh.
+
+\membersection{wxClipboardClient::BeingReplaced}
+
+\func{void}{BeingReplaced}{\void}
+
+This method is called when the client is losing the selection.
+
+\membersection{wxClipboardClient::GetData}
+
+\func{char*}{GetData}{\param{const wxString\& }{format}, \param{long *}{size}}
+
+This method is called when someone wants the data this client is
+supplying to the clipboard.
+
+{\it format} is a string indicating the
+format of the data - one of the strings from the ``formats"
+list.
+
+{\it size} should be filled with the size of the resulting
+data. In the case of text, {\it size} does not count the
+NULL terminator.
+
+

docs/latex/wx/closeevt.tex

@@ -0,0 +1,95 @@
+\section{\class{wxCloseEvent}}\label{wxcloseevent}
+
+This event class contains information about window and session close events.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}
+
+\wxheading{Event table macros}
+
+To process a close event, use these event handler macros to direct input to member
+functions that take a wxCloseEvent argument.
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_CLOSE(func)}}{Process a close event, supplying the member function. This
+event applies to wxFrame and wxDialog classes.}
+\twocolitem{{\bf EVT\_QUERY\_END\_SESSION(func)}}{Process a query end session event, supplying the member function.
+This event applies to wxApp only.}
+\twocolitem{{\bf EVT\__END\_SESSION(func)}}{Process an end session event, supplying the member function.
+This event applies to wxApp only.}
+\end{twocollist}%
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnCloseWindow}{wxwindowonclosewindow},\rtfsp
+\helpref{wxWindow::Close}{wxwindowclose},\rtfsp
+\helpref{wxApp::OnQueryEndSession}{wxapponqueryendsession},\rtfsp
+\helpref{wxApp::OnEndSession}{wxapponendsession},\rtfsp
+\helpref{Window deletion overview}{windowdeletionoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCloseEvent::wxCloseEvent}
+
+\func{}{wxCloseEvent}{\param{WXTYPE}{ commandEventType = 0}, \param{int}{ id = 0}}
+
+Constructor.
+
+\membersection{wxCloseEvent::CanVeto}\label{wxcloseeventcanveto}
+
+\func{bool}{CanVeto}{\void}
+
+Returns TRUE if you can veto a system shutdown or a window close event.
+Vetoing a window close event is not possible if the calling code wishes to
+force the application to exit, and so this function must be called to check this.
+
+\membersection{wxCloseEvent::GetLoggingOff}\label{wxcloseeventgetloggingoff}
+
+\constfunc{bool}{GetLoggingOff}{\void}
+
+Returns TRUE if the user is logging off.
+
+\membersection{wxCloseEvent::GetSessionEnding}\label{wxcloseeventgetsessionending}
+
+\constfunc{bool}{GetSessionEnding}{\void}
+
+Returns TRUE if the session is ending.
+
+\membersection{wxCloseEvent::GetForce}\label{wxcloseeventgetforce}
+
+\constfunc{bool}{GetForce}{\void}
+
+Returns TRUE if the application wishes to force the window to close.
+This will shortly be obsolete, replaced by CanVeto.
+
+\membersection{wxCloseEvent::SetCanVeto}\label{wxcloseeventsetcanveto}
+
+\func{void}{SetCanVeto}{\param{bool}{ canVeto}}
+
+Sets the 'can veto' flag.
+
+\membersection{wxCloseEvent::SetForce}\label{wxcloseeventsetforce}
+
+\constfunc{void}{SetForce}{\param{bool}{ force}}
+
+Sets the 'force' flag.
+
+\membersection{wxCloseEvent::SetLoggingOff}\label{wxcloseeventsetloggingoff}
+
+\constfunc{void}{SetLoggingOff}{\param{bool}{ loggingOff}}
+
+Sets the 'logging off' flag.
+
+\membersection{wxCloseEvent::Veto}\label{wxcloseeventveto}
+
+\func{void}{Veto}{\param{bool}{ veto = TRUE}}
+
+Call this from your event handler to veto a system shutdown or to signal
+to the calling application that a window close did not happen.
+
+You can only veto a shutdown if \helpref{wxCloseEvent::CanVeto}{wxcloseeventcanveto} returns
+TRUE.
+
+

docs/latex/wx/cmdevent.tex

@@ -0,0 +1,188 @@
+\section{\class{wxCommandEvent}}\label{wxcommandevent}
+
+This event class contains information about command events, which originate from a variety of
+simple controls. More complex controls, such as \helpref{wxTreeCtrl}{wxtreectrl}, have separate command event classes.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}
+
+\wxheading{Event table macros}
+
+To process a menu command event, use these event handler macros to direct input to member
+functions that take a wxCommandEvent argument.
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_COMMAND(id, cmd, func)}}{Process a command, supplying the window identifier,
+command event identifier, and member function.}
+\twocolitem{{\bf EVT\_COMMAND\_RANGE(id1, id2, cmd, func)}}{Process a command for a range
+of window identifiers, supplying the minimum and maximum window identifiers,
+command event identifier, and member function.}
+\twocolitem{{\bf EVT\_BUTTON(id, func)}}{Process a wxEVT\_COMMAND\_BUTTON\_CLICKED command,
+which is generated by a wxButton control.}
+\twocolitem{{\bf EVT\_CHECKBOX(id, func)}}{Process a wxEVT\_COMMAND\_CHECKBOX\_CLICKED command,
+which is generated by a wxCheckBox control.}
+\twocolitem{{\bf EVT\_CHOICE(id, func)}}{Process a wxEVT\_COMMAND\_CHOICE\_SELECTED command,
+which is generated by a wxChoice control.}
+\twocolitem{{\bf EVT\_LISTBOX(id, func)}}{Process a wxEVT\_COMMAND\_LISTBOX\_SELECTED command,
+which is generated by a wxListBox control.}
+\twocolitem{{\bf EVT\_LISTBOX\_DCLICK(id, func)}}{Process a wxEVT\_COMMAND\_LISTBOX\_DOUBLECLICKED command,
+which is generated by a wxListBox control.}
+\twocolitem{{\bf EVT\_TEXT(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_UPDATED command,
+which is generated by a wxTextCtrl control.}
+\twocolitem{{\bf EVT\_TEXT\_ENTER(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_ENTER command,
+which is generated by a wxTextCtrl control.}
+\twocolitem{{\bf EVT\_MENU(id, func)}}{Process a wxEVT\_COMMAND\_MENU\_SELECTED command,
+which is generated by a menu item.}
+\twocolitem{{\bf EVT\_MENU\_RANGE(id1, id2, func)}}{Process a wxEVT\_COMMAND\_MENU\_RANGE command,
+which is generated by a range of menu items.}
+\twocolitem{{\bf EVT\_SLIDER(id, func)}}{Process a wxEVT\_COMMAND\_SLIDER\_UPDATED command,
+which is generated by a wxSlider control.}
+\twocolitem{{\bf EVT\_RADIOBOX(id, func)}}{Process a wxEVT\_COMMAND\_RADIOBOX\_SELECTED command,
+which is generated by a wxRadioBox control.}
+\twocolitem{{\bf EVT\_RADIOBUTTON(id, func)}}{Process a wxEVT\_COMMAND\_RADIOBUTTON\_SELECTED command,
+which is generated by a wxRadioButton control.}
+\twocolitem{{\bf EVT\_SCROLLBAR(id, func)}}{Process a wxEVT\_COMMAND\_SCROLLBAR\_UPDATED command,
+which is generated by a wxScrollBar control. This is provided for compatibility only;
+more specific scrollbar event macros should be used instead (see \helpref{wxScrollEvent}{wxscrollevent}).}
+\twocolitem{{\bf EVT\_COMBOBOX(id, func)}}{Process a wxEVT\_COMMAND\_COMBOBOX\_SELECTED command,
+which is generated by a wxComboBox control.}
+\twocolitem{{\bf EVT\_TOOL(id, func)}}{Process a wxEVT\_COMMAND\_TOOL\_CLICKED event
+(a synonym for wxEVT\_COMMAND\_MENU\_SELECTED). Pass the id of the tool.}
+\twocolitem{{\bf EVT\_TOOL\_RANGE(id1, id2, func)}}{Process a wxEVT\_COMMAND\_TOOL\_CLICKED event
+for a range id identifiers. Pass the ids of the tools.}
+\twocolitem{{\bf EVT\_TOOL\_RCLICKED(id, func)}}{Process a wxEVT\_COMMAND\_TOOL\_RCLICKED event.
+Pass the id of the tool.}
+\twocolitem{{\bf EVT\_TOOL\_RCLICKED\_RANGE(id1, id2, func)}}{Process a wxEVT\_COMMAND\_TOOL\_RCLICKED event
+for a range of ids. Pass the ids of the tools.}
+\twocolitem{{\bf EVT\_TOOL\_ENTER(id, func)}}{Process a wxEVT\_COMMAND\_TOOL\_ENTER event.
+Pass the id of the toolbar itself. The value of wxCommandEvent::GetSelection is the tool id, or -1 if the mouse cursor has moved off a tool.}
+\twocolitem{{\bf EVT\_COMMAND\_LEFT\_CLICK(id, func)}}{Process a wxEVT\_COMMAND\_LEFT\_CLICK command,
+which is generated by a control (Windows 95 and NT only).}
+\twocolitem{{\bf EVT\_COMMAND\_LEFT\_DCLICK(id, func)}}{Process a wxEVT\_COMMAND\_LEFT\_DCLICK command,
+which is generated by a control (Windows 95 and NT only).}
+\twocolitem{{\bf EVT\_COMMAND\_RIGHT\_CLICK(id, func)}}{Process a wxEVT\_COMMAND\_RIGHT\_CLICK command,
+which is generated by a control (Windows 95 and NT only).}
+\twocolitem{{\bf EVT\_COMMAND\_SET\_FOCUS(id, func)}}{Process a wxEVT\_COMMAND\_SET\_FOCUS command,
+which is generated by a control (Windows 95 and NT only).}
+\twocolitem{{\bf EVT\_COMMAND\_KILL\_FOCUS(id, func)}}{Process a wxEVT\_COMMAND\_KILL\_FOCUS command,
+which is generated by a control (Windows 95 and NT only).}
+\twocolitem{{\bf EVT\_COMMAND\_ENTER(id, func)}}{Process a wxEVT\_COMMAND\_ENTER command,
+which is generated by a control.}
+\end{twocollist}%
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCommandEvent::m\_clientData}
+
+\member{char*}{m\_clientData}
+
+Contains a pointer to client data for listboxes and choices, if the event
+was a selection.
+
+\membersection{wxCommandEvent::m\_commandInt}
+
+\member{int}{m\_commandInt}
+
+Contains an integer identifier corresponding to a listbox, choice or
+radiobox selection (only if the event was a selection, not a
+deselection), or a boolean value representing the value of a checkbox.
+
+\membersection{wxCommandEvent::m\_commandString}
+
+\member{char*}{m\_commandString}
+
+Contains a string corresponding to a listbox or choice selection.
+
+\membersection{wxCommandEvent::m\_extraLong}
+
+\member{long}{m\_extraLong}
+
+Extra information. If the event comes from a listbox selection, it is
+a boolean determining whether the event was a selection (TRUE) or a
+deselection (FALSE). A listbox deselection only occurs for
+multiple-selection boxes, and in this case the index and string values
+are indeterminate and the listbox must be examined by the application.
+
+\membersection{wxCommandEvent::wxCommandEvent}
+
+\func{}{wxCommandEvent}{\param{WXTYPE}{ commandEventType = 0}, \param{int}{ id = 0}}
+
+Constructor.
+
+\membersection{wxCommandEvent::Checked}
+
+\func{bool}{Checked}{\void}
+
+Returns TRUE or FALSE for a checkbox selection event.
+
+\membersection{wxCommandEvent::GetClientData}
+
+\func{char*}{GetClientData}{\void}
+
+Returns client data pointer for a listbox or choice selection event
+(not valid for a deselection).
+
+\membersection{wxCommandEvent::GetExtraLong}
+
+\func{long}{GetExtraLong}{\void}
+
+Returns the {\bf m\_extraLong} member.
+
+\membersection{wxCommandEvent::GetInt}
+
+\func{int}{GetInt}{\void}
+
+Returns the {\bf m\_commandInt} member.
+
+\membersection{wxCommandEvent::GetSelection}
+
+\func{int}{GetSelection}{\void}
+
+Returns item index for a listbox or choice selection event (not valid for
+a deselection).
+
+\membersection{wxCommandEvent::GetString}
+
+\func{char*}{GetString}{\void}
+
+Returns item string for a listbox or choice selection event (not valid for
+a deselection).
+
+\membersection{wxCommandEvent::IsSelection}
+
+\func{bool}{IsSelection}{\void}
+
+For a listbox or choice event, returns TRUE if it is a selection, FALSE if it
+is a deselection.
+
+\membersection{wxCommandEvent::SetClientData}
+
+\func{void}{SetClientData}{\param{char*}{ clientData}}
+
+Sets the client data for this event.
+
+\membersection{wxCommandEvent::SetExtraLong}
+
+\func{void}{SetExtraLong}{\param{int}{ extraLong}}
+
+Sets the {\bf m\_extraLong} member.
+
+\membersection{wxCommandEvent::SetInt}
+
+\func{void}{SetInt}{\param{int}{ intCommand}}
+
+Sets the {\bf m\_commandInt} member.
+
+\membersection{wxCommandEvent::SetString}
+
+\func{void}{SetString}{\param{char*}{ string}}
+
+Sets the {\bf m\_commandString} member.
+
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "referenc"
+%%% End: 

docs/latex/wx/cmdproc.tex

@@ -0,0 +1,106 @@
+\section{\class{wxCommandProcessor}}\label{wxcommandprocessor}
+
+wxCommandProcessor is a class that maintains a history of wxCommands,
+with undo/redo functionality built-in. Derive a new class from this
+if you want different behaviour.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxCommandProcessor overview}{wxcommandprocessoroverview}, \helpref{wxCommand}{wxcommand}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCommandProcessor::wxCommandProcessor}
+
+\func{}{wxCommandProcessor}{\param{int}{ maxCommands = 100}}
+
+Constructor.
+
+{\it maxCommands} defaults to a rather arbitrary 100, but can be set from 1 to any integer.
+If your wxCommand classes store a lot of data, you may wish the limit the number of
+commands stored to a smaller number.
+
+\membersection{wxCommandProcessor::\destruct{wxCommandProcessor}}
+
+\func{}{\destruct{wxCommandProcessor}}{\void}
+
+Destructor.
+
+\membersection{wxCommandProcessor::CanUndo}
+
+\func{virtual bool}{CanUndo}{\void}
+
+Returns TRUE if the currently-active command can be undone, FALSE otherwise.
+
+\membersection{wxCommandProcessor::ClearCommands}
+
+\func{virtual void}{ClearCommands}{\void}
+
+Deletes all the commands in the list and sets the current command pointer to NULL.
+
+\membersection{wxCommandProcessor::Do}
+
+\func{virtual bool}{Do}{\void}
+
+Executes (redoes) the current command (the command that has just been undone if any).
+
+\membersection{wxCommandProcessor::GetCommands}
+
+\constfunc{wxList\&}{GetCommands}{\void}
+
+Returns the list of commands.
+
+\membersection{wxCommandProcessor::GetMaxCommands}
+
+\constfunc{int}{GetMaxCommands}{\void}
+
+Returns the maximum number of commands that the command processor stores.
+
+\membersection{wxCommandProcessor::GetEditMenu}
+
+\constfunc{wxMenu*}{GetEditMenu}{\void}
+
+Returns the edit menu associated with the command processor.
+
+\membersection{wxCommandProcessor::Initialize}
+
+\func{virtual void}{Initialize}{\void}
+
+Initializes the command processor, setting the current command to the
+last in the list (if any), and updating the edit menu (if one has been
+specified).
+
+\membersection{wxCommandProcessor::SetEditMenu}
+
+\func{void}{SetEditMenu}{\param{wxMenu* }{menu}}
+
+Tells the command processor to update the Undo and Redo items on this
+menu as appropriate. Set this to NULL if the menu is about to be
+destroyed and command operations may still be performed, or the command
+processor may try to access an invalid pointer.
+
+\membersection{wxCommandProcessor::Submit}
+
+\func{virtual bool}{Submit}{\param{wxCommand *}{command}, \param{bool}{ storeIt = TRUE}}
+
+Submits a new command to the command processor. The command processor
+calls wxCommand::Do to execute the command; if it succeeds, the command
+is stored in the history list, and the associated edit menu (if any) updated
+appropriately. If it fails, the command is deleted
+immediately. Once Submit has been called, the passed command should not
+be deleted directly by the application.
+
+{\it storeIt} indicates whether the successful command should be stored
+in the history list.
+
+\membersection{wxCommandProcessor::Undo}
+
+\func{virtual bool}{Undo}{\void}
+
+Undoes the command just executed.
+
+

docs/latex/wx/colordlg.tex

@@ -0,0 +1,48 @@
+\section{\class{wxColourDialog}}\label{wxcolourdialog}
+
+This class represents the colour chooser dialog.
+
+\wxheading{Derived from}
+
+\helpref{wxDialog}{wxdialog}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxColourDialog Overview}{wxcolourdialogoverview}, \helpref{wxColour}{wxcolour}, \helpref{wxColourData}{wxcolourdata}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxColourDialog::wxColourDialog}
+
+\func{}{wxColourDialog}{\param{wxWindow* }{parent}, \param{wxColourData* }{data = NULL}}
+
+Constructor. Pass a parent window, and optionally a pointer to a block of colour
+data, which will be copied to the colour dialog's colour data.
+
+\wxheading{See also}
+
+\helpref{wxColourData}{wxcolourdata}
+
+\membersection{wxColourDialog::\destruct{wxColourDialog}}
+
+\func{}{\destruct{wxColourDialog}}{\void}
+
+Destructor.
+
+\membersection{wxColourDialog::GetColourData}
+
+\func{wxColourData\&}{GetColourData}{\void}
+
+Returns the \helpref{colour data}{wxcolourdata} associated with the colour dialog.
+
+\membersection{wxColourDialog::ShowModal}
+
+\func{int}{ShowModal}{\void}
+
+Shows the dialog, returning wxID\_OK if the user pressed OK, and wxOK\_CANCEL
+otherwise.
+
+

docs/latex/wx/colour.tex

@@ -0,0 +1,266 @@
+\section{\class{wxColour}}\label{wxcolour}
+
+A colour is an object representing a combination of Red, Green, and Blue (RGB) intensity values,
+and is used to determine drawing colours. See the
+entry for \helpref{wxColourDatabase}{wxcolourdatabase} for how a pointer to a predefined,
+named colour may be returned instead of creating a new colour.
+
+Valid RGB values are in the range 0 to 255.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxColourDatabase}{wxcolourdatabase}, \helpref{wxPen}{wxpen}, \helpref{wxBrush}{wxbrush},\rtfsp
+\helpref{wxColourDialog}{wxcolourdialog}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxColour::wxColour}\label{wxcolourconstr}
+
+\func{}{wxColour}{\void}
+
+Default constructor.
+
+\func{}{wxColour}{\param{const unsigned char}{ red}, \param{const unsigned char}{ green}, \param{const unsigned char}{ blue}}
+
+Constructs a colour from red, green and blue values.
+
+\func{}{wxColour}{\param{const wxString\& }{colourNname}}
+
+Constructs a colour object using a colour name
+listed in {\bf wxTheColourDatabase}.
+
+\wxheading{Parameters}
+
+\docparam{red}{The red value.}
+
+\docparam{green}{The green value.}
+
+\docparam{blue}{The blue value.}
+
+\docparam{colourName}{The colour name.}
+
+\wxheading{See also}
+
+\helpref{wxColourDatabase}{wxcolourdatabase}
+
+\membersection{wxColour::Blue}\label{wxcolourblue}
+
+\constfunc{unsigned char}{Blue}{\void}
+
+Returns the blue intensity.
+
+\membersection{wxColour::GetPixel}\label{wxcolourgetpixel}
+
+\constfunc{long}{GetPixel}{\void}
+
+Returns a pixel value which is platform-dependent. On Windows, a COLORREF is returned.
+On X, an allocated pixel value is returned.
+
+-1 is returned if the pixel is invalid (on X, unallocated).
+
+\membersection{wxColour::Green}\label{wxcolourgreen}
+
+\constfunc{unsigned char}{Green}{\void}
+
+Returns the green intensity.
+
+\membersection{wxColour::Ok}\label{wxcolourok}
+
+\constfunc{bool}{Ok}{\void}
+
+Returns TRUE if the colour object is valid (the colour has been initialised with RGB values).
+
+\membersection{wxColour::Red}\label{wxcolourred}
+
+\constfunc{unsigned char}{Red}{\void}
+
+Returns the red intensity.
+
+\membersection{wxColour::Set}\label{wxcolourset}
+
+\func{void}{Set}{\param{const unsigned char}{ red}, \param{const unsigned char}{ green}, \param{const unsigned char}{ blue}}
+
+Sets the RGB intensity values.
+
+\membersection{wxColour::operator $=$}\label{wxcolourassign}
+
+\func{wxColour\&}{operator $=$}{\param{const wxColour\&}{ colour}}
+
+Assignment operator, taking another colour object.
+
+\func{wxColour\&}{operator $=$}{\param{const wxString\&}{ colourName}}
+
+Assignment operator, using a colour name to be found in the colour database.
+
+\wxheading{See also}
+
+\helpref{wxColourDatabase}{wxcolourdatabase}
+
+\membersection{wxColour::operator $==$}\label{wxcolourequality}
+
+\func{bool}{operator $==$}{\param{const wxColour\&}{ colour}}
+
+Tests the equality of two colours by comparing individual red, green blue colours.
+
+TODO: this may be different on platforms other than Windows - no reference counting
+is done on Windows.
+
+\membersection{wxColour::operator $!=$}\label{wxcolourinequality}
+
+\func{bool}{operator $!=$}{\param{const wxColour\&}{ colour}}
+
+Tests the inequality of two colours by comparing individual red, green blue colours.
+
+TODO: this may be different on platforms other than Windows - no reference counting
+is done on Windows.
+
+\section{\class{wxColourData}}\label{wxcolourdata}
+
+This class holds a variety of information related to colour dialogs.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxColour}{wxcolour}, \helpref{wxColourDialog}{wxcolourdialog}, \helpref{wxColourDialog overview}{wxcolourdialogoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxColourData::wxColourData}\label{wxcolourdataconstr}
+
+\func{}{wxColourData}{\void}
+
+Constructor. Initializes the custom colours to white, the {\it data colour} setting
+to black, and the {\it choose full} setting to TRUE.
+
+\membersection{wxColourData::\destruct{wxColourData}}
+
+\func{}{\destruct{wxColourData}}{\void}
+
+Destructor.
+
+\membersection{wxColourData::GetChooseFull}\label{wxcolourdatagetchoosefull}
+
+\constfunc{bool}{GetChooseFull}{\void}
+
+Under Windows, determines whether the Windows colour dialog will display the full dialog
+with custom colour selection controls. Has no meaning under other platforms.
+
+The default value is TRUE.
+
+\membersection{wxColourData::GetColour}\label{wxcolourdatagetcolour}
+
+\constfunc{wxColour\&}{GetColour}{\void}
+
+Gets the current colour associated with the colour dialog.
+
+The default colour is black.
+
+\membersection{wxColourData::GetCustomColour}\label{wxcolourdatagetcustomcolour}
+
+\constfunc{wxColour\&}{GetCustomColour}{\param{int}{ i}}
+
+Gets the {\it i}th custom colour associated with the colour dialog. {\it i} should
+be an integer between 0 and 15.
+
+The default custom colours are all white.
+
+\membersection{wxColourData::SetChooseFull}\label{wxcolourdatasetchoosefull}
+
+\func{void}{SetChooseFull}{\param{const bool }{flag}}
+
+Under Windows, tells the Windows colour dialog to display the full dialog
+with custom colour selection controls. Under other platforms, has no effect.
+
+The default value is TRUE.
+
+\membersection{wxColourData::SetColour}\label{wxcolourdatasetcolour}
+
+\func{void}{SetColour}{\param{const wxColour\&}{ colour}}
+
+Sets the default colour for the colour dialog.
+
+The default colour is black.
+
+\membersection{wxColourData::SetCustomColour}\label{wxcolourdatasetcustomcolour}
+
+\func{void}{SetColour}{\param{int}{ i}, \param{const wxColour\&}{ colour}}
+
+Sets the {\it i}th custom colour for the colour dialog. {\it i} should
+be an integer between 0 and 15.
+
+The default custom colours are all white.
+
+\membersection{wxColourData::operator $=$}\label{wxcolourdataassign}
+
+\func{void}{operator $=$}{\param{const wxColourData\&}{ data}}
+
+Assingment operator for the colour data.
+
+\section{\class{wxColourDatabase}}\label{wxcolourdatabase}
+
+wxWindows maintains a database of standard RGB colours for a predefined
+set of named colours (such as ``BLACK'', ``LIGHT GREY''). The
+application may add to this set if desired by using {\it Append}.  There
+is only one instance of this class: {\bf wxTheColourDatabase}.
+
+\wxheading{Derived from}
+
+\helpref{wxList}{wxlist}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Remarks}
+
+The colours in the standard database are as follows:
+
+AQUAMARINE, BLACK, BLUE, BLUE VIOLET, BROWN, CADET BLUE, CORAL,
+CORNFLOWER BLUE, CYAN, DARK GREY, DARK GREEN, DARK OLIVE GREEN, DARK
+ORCHID, DARK SLATE BLUE, DARK SLATE GREY DARK TURQUOISE, DIM GREY,
+FIREBRICK, FOREST GREEN, GOLD, GOLDENROD, GREY, GREEN, GREEN YELLOW,
+INDIAN RED, KHAKI, LIGHT BLUE, LIGHT GREY, LIGHT STEEL BLUE, LIME GREEN,
+MAGENTA, MAROON, MEDIUM AQUAMARINE, MEDIUM BLUE, MEDIUM FOREST GREEN,
+MEDIUM GOLDENROD, MEDIUM ORCHID, MEDIUM SEA GREEN, MEDIUM SLATE BLUE,
+MEDIUM SPRING GREEN, MEDIUM TURQUOISE, MEDIUM VIOLET RED, MIDNIGHT BLUE,
+NAVY, ORANGE, ORANGE RED, ORCHID, PALE GREEN, PINK, PLUM, PURPLE, RED,
+SALMON, SEA GREEN, SIENNA, SKY BLUE, SLATE BLUE, SPRING GREEN, STEEL
+BLUE, TAN, THISTLE, TURQUOISE, VIOLET, VIOLET RED, WHEAT, WHITE, YELLOW,
+YELLOW GREEN.
+
+\wxheading{See also}
+
+\helpref{wxColour}{wxcolour}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxColourDatabase::wxColourDatabase}\label{wxcolourdatabaseconstr}
+
+\func{}{wxColourDatabase}{\void}
+
+Constructs the colour database.
+
+\membersection{wxColourDatabase::FindColour}\label{wxcolourdatabasefindcolour}
+
+\func{wxColour*}{FindColour}{\param{const wxString\& }{colourName}}
+
+Finds a colour given the name. Returns NULL if not found.
+
+\membersection{wxColourDatabase::FindName}\label{wxcolourdatabasefindname}
+
+\constfunc{wxString}{FindName}{\param{const wxColour\&}{ colour}}
+
+Finds a colour name given the colour. Returns NULL if not found.
+
+\membersection{wxColourDatabase::Initialize}\label{wxcolourdatabaseinitialize}
+
+\func{void}{Initialize}{\void}
+
+Initializes the database with a number of stock colours.  Called by wxWindows
+on start-up.
+
+

docs/latex/wx/combobox.tex

@@ -0,0 +1,314 @@
+\section{\class{wxComboBox}}\label{wxcombobox}
+
+A combobox is like a combination of an edit control and a listbox. It can be
+displayed as static list with editable or read-only text field; or a drop-down list with
+text field; or a drop-down list without a text field.
+
+A combobox permits a single selection only. Combobox items are numbered from zero.
+
+\wxheading{Derived from}
+
+\helpref{wxChoice}{wxchoice}\\
+\helpref{wxControl}{wxcontrol}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Window styles}
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxCB\_SIMPLE}}{Creates a combobox with a permanently displayed list.}
+\twocolitem{\windowstyle{wxCB\_DROPDOWN}}{Creates a combobox with a drop-down list.}
+\twocolitem{\windowstyle{wxCB\_READONLY}}{Creates a combo box consisting of a drop-down list and static text item
+displaying the current selection.}
+\twocolitem{\windowstyle{wxCB\_SORT}}{Sorts the entries in the list alphabetically.}
+\end{twocollist}
+
+See also \helpref{window styles overview}{windowstyles}.
+
+\wxheading{Event handling}
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_COMBOBOX(id, func)}}{Process a wxEVT\_COMMAND\_COMBOBOX\_SELECTED event,
+when an item on the list is selected.}
+\twocolitem{{\bf EVT\_TEXT(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_UPDATED event,
+when the combobox text changes.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxListBox}{wxlistbox}, \helpref{wxTextCtrl}{wxtextctrl}, \helpref{wxChoice}{wxchoice},
+\rtfsp\helpref{wxCommandEvent}{wxcommandevent}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxComboBox::wxComboBox}\label{wxcomboboxconstr}
+
+\func{}{wxComboBox}{\void}
+
+Default constructor.
+
+\func{}{wxComboBox}{\param{wxWindow*}{ parent}, \param{wxWindowID}{ id},\rtfsp
+\param{const wxString\& }{value = ``"}, \param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
+\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
+\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``comboBox"}}
+
+Constructor, creating and showing a combobox.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window. Must not be NULL.}
+
+\docparam{id}{Window identifier. A value of -1 indicates a default value.}
+
+\docparam{pos}{Window position.}
+
+\docparam{size}{Window size. If the default size (-1, -1) is specified then the window is sized
+appropriately.}
+
+\docparam{n}{Number of strings with which to initialise the control.}
+
+\docparam{choices}{An array of strings with which to initialise the control.}
+
+\docparam{style}{Window style. See \helpref{wxComboBox}{wxcombobox}.}
+
+\docparam{validator}{Window validator.}
+
+\docparam{name}{Window name.}
+
+\wxheading{See also}
+
+\helpref{wxComboBox::Create}{wxcomboboxcreate}, \helpref{wxValidator}{wxvalidator}
+
+\membersection{wxComboBox::\destruct{wxComboBox}}
+
+\func{}{\destruct{wxComboBox}}{\void}
+
+Destructor, destroying the combobox.
+
+\membersection{wxComboBox::Append}\label{wxcomboboxappend}
+
+\func{void}{Append}{\param{const wxString\& }{item}}
+
+Adds the item to the end of the combobox.
+
+\func{void}{Append}{\param{const wxString\& }{ item}, \param{char* }{clientData}}
+
+Adds the item to the end of the combobox, associating the given data
+with the item.
+
+\wxheading{Parameters}
+
+\docparam{item}{The string to add.}
+
+\docparam{clientData}{Client data to associate with the item.}
+
+\membersection{wxComboBox::Clear}\label{wxcomboboxclear}
+
+\func{void}{Clear}{\void}
+
+Clears all strings from the combobox.
+
+\membersection{wxComboBox::Create}\label{wxcomboboxcreate}
+
+\func{bool}{Create}{\param{wxWindow*}{ parent}, \param{wxWindowID}{ id},\rtfsp
+\param{const wxString\& }{value = ``"}, \param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},\rtfsp
+\param{int}{ n}, \param{const wxString }{choices[]},\rtfsp
+\param{long}{ style = 0}, \param{const wxValidator\& }{validator = wxDefaultValidator}, \param{const wxString\& }{name = ``comboBox"}}
+
+Creates the combobox for two-step construction. Derived classes
+should call or replace this function. See \helpref{wxComboBox::wxComboBox}{wxcomboboxconstr}\rtfsp
+for further details.
+
+\membersection{wxComboBox::Copy}\label{wxcomboboxcopy}
+
+\func{void}{Copy}{\void}
+
+Copies the selected text to the clipboard.
+
+\membersection{wxComboBox::Cut}\label{wxcomboboxcut}
+
+\func{void}{Cut}{\void}
+
+Copies the selected text to the clipboard and removes the selection.
+
+\membersection{wxComboBox::Delete}\label{wxcomboboxdelete}
+
+\func{void}{Delete}{\param{int}{ n}}
+
+Deletes an item from the combobox.
+
+\wxheading{Parameters}
+
+\docparam{n}{The item to delete, starting from zero.}
+
+\membersection{wxComboBox::FindString}\label{wxcomboboxfindstring}
+
+\func{int}{FindString}{\param{const wxString\& }{string}}
+
+Finds a choice matching the given string.
+
+\wxheading{Parameters}
+
+\docparam{string}{The item to find.}
+
+\wxheading{Return value}
+
+The position if found, or -1 if not found.
+
+\membersection{wxComboBox::GetClientData}\label{wxcomboboxgetclientdata}
+
+\constfunc{char*}{GetClientData}{\param{int}{ n}}
+
+Returns a pointer to the client data associated with the given item (if any).
+
+\wxheading{Parameters}
+
+\docparam{n}{An item, starting from zero.}
+
+\wxheading{Return value}
+
+A pointer to the client data, or NULL if the item was not found.
+
+\membersection{wxComboBox::GetInsertionPoint}\label{wxcomboboxgetinsertionpoint}
+
+\constfunc{long}{GetInsertionPoint}{\void}
+
+Returns the insertion point for the combobox's text field.
+
+\membersection{wxComboBox::GetLastPosition}\label{wxcomboboxgetlastposition}
+
+\constfunc{long}{GetLastPosition}{\void}
+
+Returns the last position in the combobox text field.
+
+\membersection{wxComboBox::GetSelection}\label{wxcomboboxgetselection}
+
+\constfunc{int}{GetSelection}{\void}
+
+Gets the position of the selected string, or -1 if there is no selection.
+
+\membersection{wxComboBox::GetString}\label{wxcomboboxgetstring}
+
+\constfunc{wxString}{GetString}{\param{int}{ n}}
+
+Returns the string at position {\it n}.
+
+\wxheading{Parameters}
+
+\docparam{n}{The item position, starting from zero.}
+
+\wxheading{Return value}
+
+The string if the item is found, otherwise the empty string.
+
+\membersection{wxComboBox::GetStringSelection}\label{wxcomboboxgetstringselection}
+
+\constfunc{wxString}{GetStringSelection}{\void}
+
+Gets the selected string.
+
+\membersection{wxComboBox::GetValue}\label{wxcomboboxgetvalue}
+
+\constfunc{wxString}{GetValue}{\void}
+
+Returns the current value in the combobox text field.
+
+\membersection{wxComboBox::Number}\label{wxcomboboxnumber}
+
+\constfunc{int}{Number}{\void}
+
+Returns the number of items in the combobox list.
+
+TODO: make this GetNumber or GetCount?
+
+\membersection{wxComboBox::Paste}\label{wxcomboboxpaste}
+
+\func{void}{Paste}{\void}
+
+Pastes text from the clipboard to the text field.
+
+\membersection{wxComboBox::Replace}\label{wxcomboboxreplace}
+
+\func{void}{Replace}{\param{long}{ from}, \param{long}{ to}, \param{const wxString\& }{text}}
+
+Replaces the text between two positions with the given text, in the combobox text field.
+
+\wxheading{Parameters}
+
+\docparam{from}{The first position.}
+
+\docparam{to}{The second position.}
+
+\docparam{text}{The text to insert.}
+
+\membersection{wxComboBox::Remove}\label{wxcomboboxremove}
+
+\func{void}{Remove}{\param{long}{ from}, \param{long}{ to}}
+
+Removes the text between the two positions in the combobox text field.
+
+\wxheading{Parameters}
+
+\docparam{from}{The first position.}
+
+\docparam{to}{The last position.}
+
+\membersection{wxComboBox::SetClientData}\label{wxcomboboxsetclientdata}
+
+\func{void}{SetClientData}{\param{int}{ n}, \param{char* }{data}}
+
+Associates the given client data pointer with the given item.
+
+\wxheading{Parameters}
+
+\docparam{n}{The zero-based item.}
+
+\docparam{data}{The client data.}
+
+\membersection{wxComboBox::SetInsertionPoint}\label{wxcomboboxsetinsertionpoint}
+
+\func{void}{SetInsertionPoint}{\param{long}{ pos}}
+
+Sets the insertion point in the combobox text field.
+
+\wxheading{Parameters}
+
+\docparam{pos}{The new insertion point.}
+
+\membersection{wxComboBox::SetInsertionPointEnd}\label{wxcomboboxsetinsertionpointend}
+
+\func{void}{SetInsertionPointEnd}{\void}
+
+Sets the insertion point at the end of the combobox text field.
+
+\membersection{wxComboBox::SetSelection}\label{wxcomboboxsetselection}
+
+\func{void}{SetSelection}{\param{int}{ n}}
+
+Selects the given item in the combobox list.
+
+\func{void}{SetSelection}{\param{long}{ from}, \param{long}{ to}}
+
+Selects the text between the two positions, in the combobox text field.
+
+\wxheading{Parameters}
+
+\docparam{n}{The zero-based item to select.}
+
+\docparam{from}{The first position.}
+
+\docparam{to}{The second position.}
+
+\membersection{wxComboBox::SetValue}\label{wxcomboboxsetvalue}
+
+\func{void}{SetValue}{\param{const wxString\& }{text}}
+
+Sets the text for the combobox text field.
+
+\wxheading{Parameters}
+
+\docparam{text}{The text to set.}
+
+

docs/latex/wx/command.tex

@@ -0,0 +1,85 @@
+\section{\class{wxCommand}}\label{wxcommand}
+
+wxCommand is a base class for modelling an application command,
+which is an action usually performed by selecting a menu item, pressing
+a toolbar button or any other means provided by the application to
+change the data or view.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\overview{Overview}{wxcommandoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCommand::wxCommand}
+
+\func{}{wxCommand}{\param{bool}{ canUndo = FALSE}, \param{const wxString\& }{name = NULL}}
+
+Constructor. wxCommand is an abstract class, so you will need to derive
+a new class and call this constructor from your own constructor.
+
+{\it canUndo} tells the command processor whether this command is undo-able. You
+can achieve the same functionality by overriding the CanUndo member function (if for example
+the criteria for undoability is context-dependant).
+
+{\it name} must be supplied for the command processor to display the command name
+in the application's edit menu.
+
+\membersection{wxCommand::\destruct{wxCommand}}
+
+\func{}{\destruct{wxCommand}}{\void}
+
+Destructor.
+
+\membersection{wxCommand::CanUndo}
+
+\func{bool}{CanUndo}{\void}
+
+Returns TRUE if the command can be undone, FALSE otherwise.
+
+\membersection{wxCommand::Do}
+
+\func{bool}{Do}{\void}
+
+Override this member function to execute the appropriate action when called.
+Return TRUE to indicate that the action has taken place, FALSE otherwise.
+Returning FALSE will indicate to the command processor that the action is
+not undoable and should not be added to the command history.
+
+\membersection{wxCommand::GetName}
+
+\func{wxString}{GetName}{\void}
+
+Returns the command name.
+
+\membersection{wxCommand::Undo}
+
+\func{bool}{Undo}{\void}
+
+Override this member function to un-execute a previous Do.
+Return TRUE to indicate that the action has taken place, FALSE otherwise.
+Returning FALSE will indicate to the command processor that the action is
+not redoable and no change should be made to the command history.
+
+How you implement this command is totally application dependent, but typical
+strategies include:
+
+\begin{itemize}\itemsep=0pt
+\item Perform an inverse operation on the last modified piece of
+data in the document. When redone, a copy of data stored in command
+is pasted back or some operation reapplied. This relies on the fact that
+you know the ordering of Undos; the user can never Undo at an arbitrary position
+in the command history.
+\item Restore the entire document state (perhaps using document transactioning).
+Potentially very inefficient, but possibly easier to code if the user interface
+and data are complex, and an `inverse execute' operation is hard to write.
+\end{itemize}
+
+The docview sample uses the first method, to remove or restore segments
+in the drawing.
+
+

docs/latex/wx/conditn.tex

@@ -0,0 +1,61 @@
+\section{\class{wxCondition}}\label{wxcondition}
+
+TODO
+
+\wxheading{Derived from}
+
+None.
+
+\wxheading{See also}
+
+\helpref{wxThread}{wxthread}, \helpref{wxMutex}{wxmutex}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCondition::wxCondition}\label{wxconditionconstr}
+
+\func{}{wxCondition}{\void}
+
+Default constructor.
+
+\membersection{wxCondition::\destruct{wxCondition}}
+
+\func{}{\destruct{wxCondition}}{\void}
+
+Destroys the wxCondition object.
+
+\membersection{wxCondition::Broadcast}\label{wxconditionbroadcast}
+
+\func{void}{Broadcast}{\void}
+
+Broadcasts to all waiting objects.
+
+\membersection{wxCondition::Signal}\label{wxconditionsignal}
+
+\func{void}{Signal}{\void}
+
+Signals the object.
+
+\membersection{wxCondition::Wait}\label{wxconditionwait}
+
+\func{void}{Wait}{\param{wxMutex\&}{ mutex}}
+
+Waits indefinitely.
+
+\func{bool}{Wait}{\param{wxMutex\&}{ mutex}, \param{unsigned long}{ sec}, \param{unsigned long}{ nsec}}
+
+Waits until a signal is raised or the timeout has elapsed.
+
+\wxheading{Parameters}
+
+\docparam{mutex}{wxMutex object.}
+
+\docparam{sec}{Timeout in seconds}
+
+\docparam{nsec}{Timeout nanoseconds component (added to {\it sec}).}
+
+\wxheading{Return value}
+
+The second form returns if the signal was raised, or FALSE if there was a timeout.
+
+

docs/latex/wx/config.tex

@@ -0,0 +1,621 @@
+\section{\class{wxConfigBase}}\label{wxconfigbase}
+
+wxConfigBase class defines the basic interface of all config classes. It can
+not be used by itself (it's an abstract base class) and you'll always use one
+of its derivations: wxIniConfig, wxFileConfig, wxRegConfig or any other.
+
+However, usually you don't even need to know the precise nature of the class
+you're working with but you would just use the wxConfigBase methods. This
+allows you to write the same code regardless of whether you're working with
+the registry under Win32 or text-based config files under Unix (or even
+Windows 3.1 .INI files if you're really unlucky). To make writing the portable
+code even easier, wxWindows provides a typedef wxConfig
+which is mapped onto the native wxConfigBase implementation on the given
+platform: i.e. wxRegConfig under Win32, wxIniConfig under Win16 and
+wxFileConfig otherwise.
+
+See \helpref{config overview}{wxconfigoverview} for the descriptions of all
+features of this class.
+
+\wxheading{Derived from}
+
+No base class
+
+\wxheading{Example}
+
+Here is how you would typically use this class:
+
+\begin{verbatim}
+  // using wxConfig instead of writing wxFileConfig or wxRegConfig enhances
+  // portability of the code
+  wxConfig *config = new wxConfig("MyAppName");
+
+  wxString str;
+  if ( config->Read("LastPrompt", &str) ) {
+    // last prompt was found in the config file/registry and its value is now
+    // in str
+    ...
+  }
+  else {
+    // no last prompt...
+  }
+
+  // another example: using default values and the full path instead of just
+  // key name: if the key is not found , the value 17 is returned
+  long value = config->Read("/LastRun/CalculatedValues/MaxValue", -1);
+  ...
+  ...
+  ...
+  // at the end of the program we would save everything back
+  config->Write("LastPrompt", str);
+  config->Write("/LastRun/CalculatedValues/MaxValue", value);
+
+  // the changes will be written back automatically
+  delete config;
+\end{verbatim}
+
+This basic example, of course, doesn't show all wxConfig features, such as
+enumerating, testing for existence and deleting the entries and groups of
+entries in the config file, its abilities to automatically store the default
+values or expand the environment variables on the fly. However, the main idea
+is that using this class is easy and that it should normally do what you
+expect it to.
+
+NB: in the documentation of this class, the words "config file" also mean
+"registry hive" for wxRegConfig and, generally speaking, might mean any
+physical storage where a wxConfigBase-derived class stores its data.
+
+\latexignore{\rtfignore{\wxheading{Function groups}}}
+
+\membersection{Static functions}
+
+These functions deal with the "default" config object. Although its usage is
+not at all mandatory it may be convenient to use a global config object
+instead of creating and deleting the local config objects each time you need
+one (especially because creating a wxFileConfig object might be a time
+consuming operation). In this case, you may create this global config object
+in the very start of the program and {\it Set()} it as the default. Then, from
+anywhere in your program, you may access it using the {\it Get()} function. Of
+course, you should delete it on the program termination (otherwise, not only a
+memory leak will result, but even more importantly the changes won't be
+written back!).
+
+As it happens, you may even further simplify the procedure described above:
+you may forget about calling {\it Set()}. When {\it Get()} is called and there
+is no current object, it will create one using {\it Create()} function. To
+disable this behaviour {\it DontCreateOnDemand()} is provided.
+
+\helpref{Set}{wxconfigbaseset}\\
+\helpref{Get}{wxconfigbaseget}\\
+\helpref{Create}{wxconfigbasecreate}\\
+\helpref{DontCreateOnDemand}{wxconfigbasedontcreateondemand}
+
+\membersection{Constructor and destructor}
+
+\helpref{wxConfigBase}{wxconfigbasector}\\
+\helpref{\destruct{wxConfigBase}}{wxconfigbasedtor}
+
+\membersection{Path management}
+
+As explained in \helpref{config overview}{wxconfigoverview}, the config classes
+support a file system-like hierarchy of keys (files) and groups (directories).
+As in the file system case, to specify a key in the config class you must use
+a path to it. Config classes also support the notion of the current group,
+which makes it possible to use the relative paths. To clarify all this, here
+is an example (it's only for the sake of demonstration, it doesn't do anything
+sensible!):
+
+\begin{verbatim}
+  wxConfig *config = new wxConfig("FooBarApp");
+
+  // right now the current path is '/'
+  conf->Write("RootEntry", 1);
+
+  // go to some other place: if the group(s) don't exist, they will be created
+  conf->SetPath("/Group/Subgroup");
+
+  // create an entry in subgroup
+  conf->Write("SubgroupEntry", 3);
+  
+  // '..' is understood
+  conf->Write("../GroupEntry", 2);
+  conf->SetPath("..");
+
+  wxASSERT( conf->Read("Subgroup/SubgroupEntry", 0l) == 3 );
+
+  // use absolute path: it's allowed, too
+  wxASSERT( conf->Read("/RootEntry", 0l) == 1 );
+\end{verbatim}
+
+{\it Warning}: it's probably a good idea to always restore the path to its
+old value on function exit:
+
+\begin{verbatim}
+  void foo(wxConfigBase *config)
+  {
+    wxString strOldPath = config->GetPath();
+
+    config->SetPath("/Foo/Data");
+    ...
+
+    config->SetPath(strOldPath);
+  }
+\end{verbatim}
+
+because otherwise the assert in the following example will surely fail
+(we suppose here that {\it foo()} function is the same as above except that it
+doesn't save and restore the path):
+
+\begin{verbatim}
+  void bar(wxConfigBase *config)
+  {
+    config->Write("Test", 17);
+    
+    foo(config);
+
+    // we're reading "/Foo/Data/Test" here! -1 will probably be returned...
+    wxASSERT( config->Read("Test", -1) == 17 );
+  }
+\end{verbatim}
+
+Finally, the path separator in wxConfigBase and derived classes is always '/',
+regardless of the platform (i.e. it's {\bf not} '$\backslash\backslash$' under Windows).
+
+\helpref{SetPath}{wxconfigbasesetpath}\\
+\helpref{GetPath}{wxconfigbasegetpath}
+
+\membersection{Enumeration}
+
+The functions in this section allow to enumerate all entries and groups in the
+config file. All functions here return FALSE when there are no more items.
+
+You must pass the same index to GetNext and GetFirst (don't modify it).
+Please note that it's {\bf not} the index of the current item (you will have
+some great surprizes with wxRegConfig if you assume this) and you shouldn't
+even look at it: it's just a "cookie" which stores the state of the
+enumeration. It can't be stored inside the class because it would prevent you
+from running several enumerations simultaneously, that's why you must pass it
+explicitly.
+
+Having said all this, enumerating the config entries/groups is very simple:
+
+\begin{verbatim}
+  wxArrayString aNames;
+
+  // enumeration variables
+  wxString str;
+  long dummy;
+
+  // first enum all entries
+  bool bCont = config->GetFirstEntry(str, dummy);
+  while ( bCont ) {
+    aNames.Add(str);
+
+    bCont = GetConfig()->GetNextEntry(str, dummy);
+  }
+
+  ... we have all entry names in aNames...
+
+  // now all groups...
+  bCont = GetConfig()->GetFirstGroup(str, dummy);
+  while ( bCont ) {
+    aNames.Add(str);
+
+    bCont = GetConfig()->GetNextGroup(str, dummy);
+  }
+
+  ... we have all group (and entry) names in aNames...
+
+\end{verbatim}
+
+There are also functions to get the number of entries/subgroups without
+actually enumerating them, but you will probably never need them.
+
+\helpref{GetFirstGroup}{wxconfigbasegetfirstgroup}\\
+\helpref{GetNextGroup}{wxconfigbasegetnextgroup}\\
+\helpref{GetFirstEntry}{wxconfigbasegetfirstentry}\\
+\helpref{GetNextEntry}{wxconfigbasegetnextentry}\\
+\helpref{GetNumberOfEntries}{wxconfigbasegetnumberofentries}\\
+\helpref{GetNumberOfGroups}{wxconfigbasegetnumberofgroups}
+
+\membersection{Tests of existence}
+
+\helpref{HasGroup}{wxconfigbasehasgroup}\\
+\helpref{HasEntry}{wxconfigbasehasentry}\\
+\helpref{Exists}{wxconfigbaseexists}
+
+\membersection{Miscellaneous accessors}
+
+\helpref{SetAppName}{wxconfigbasesetappname}\\
+\helpref{GetAppName}{wxconfigbasegetappname}\\
+\helpref{SetVendorName}{wxconfigbasesetvendorname}\\
+\helpref{GetVendorName}{wxconfigbasegetvendorname}
+
+\membersection{Key access}
+
+These function are the core of wxConfigBase class: they allow you to read and
+write config file data. All {\it Read} function take a default value which
+will be returned if the specified key is not found in the config file.
+
+Currently, only two types of data are supported: string and long (but it might
+change in the near future). To work with other types: for {\it int} or {\it
+bool} you can work with function taking/returning {\it long} and just use the
+casts. Better yet, just use {\it long} for all variables which you're going to
+save in the config file: chances are that \verb$sizeof(bool) == sizeof(int) == sizeof(long)$ anyhow on your system. For {\it float}, {\it double} and, in
+general, any other type you'd have to translate them to/from string
+representation and use string functions.
+
+Try not to read long values into string variables and vice versa: although it
+just might work with wxFileConfig, you will get a system error with
+wxRegConfig because in the Windows registry the different types of entries are
+indeed used.
+
+Final remark: the {\it szKey} parameter for all these functions can contain an
+arbitrary path (either relative or absolute), not just the key name.
+
+\helpref{Read}{wxconfigbaseread}\\
+\helpref{Write}{wxconfigbasewrite}\\
+\helpref{Flush}{wxconfigbaseflush}
+
+\membersection{Delete entries/groups}
+
+The functions in this section delete entries and/or groups of entries from the
+config file. {\it DeleteAll()} is especially useful if you want to erase all
+traces of your program presence: for example, when you uninstall it.
+
+\helpref{DeleteEntry}{wxconfigbasedeleteentry}\\
+\helpref{DeleteGroup}{wxconfigbasedeletegroup}\\
+\helpref{DeleteAll}{wxconfigbasedeleteall}
+
+\membersection{Options}
+
+Some aspects of wxConfigBase behaviour can be changed during run-time. The
+first of them is the expansion of environment variables in the string values
+read from the config file: for example, if you have the following in your
+config file:
+
+\begin{verbatim}
+  # config file for my program
+  UserData = $HOME/data
+
+  # the following syntax is valud only under Windows
+  UserData = %windir%\\data.dat
+\end{verbatim}
+
+the call to \verb$config->Read("UserData")$ will return something like
+\verb$"/home/zeitlin/data"$ if you're lucky enough to run a Linux system ;-)
+
+Although this feature is very useful, it may be annoying if you read a value
+which containts '\$' or '\%' symbols (\% is used for environment variables
+expansion under Windows) which are not used for environment variable
+expansion. In this situation you may call SetExpandEnvVars(FALSE) just before
+reading this value and SetExpandEnvVars(TRUE) just after. Another solution
+would be to prefix the offending symbols with a backslash.
+
+The following functions control this option:
+
+\helpref{IsExpandingEnvVars}{wxconfigbaseisexpandingenvvars}\\
+\helpref{SetExpandingEnvVars}{wxconfigbasesetexpandingenvvars}\\
+\helpref{SetRecordDefaults}{wxconfigbasesetrecorddefaults}\\
+\helpref{IsRecordingDefaults}{wxconfigbaseisrecordingdefaults}
+
+%%%%% MEMBERS HERE %%%%%
+\helponly{\insertatlevel{2}{
+
+\wxheading{Members}
+
+}}
+
+\membersection{wxConfigBase::wxConfigBase}\label{wxconfigbasector}
+
+\func{}{wxConfigBase}{\param{const wxString\& }{appName = wxEmptyString},
+ \param{const wxString\& }{vendorName = wxEmptyString},
+ \param{const wxString\& }{localFilename = wxEmptyString},
+ \param{const wxString\& }{globalFilename = wxEmptyString},
+ \param{long}{ style = 0}}
+
+This is the default and only constructor of the wxConfigBase class, and
+derived classes.
+
+\wxheading{Parameters}
+
+\docparam{appName}{The application name. If this is empty, the class will
+normally use \helpref{wxApp::GetAppName}{wxappgetappname} to set it. The
+application name is used in the registry key on Windows, and can be used to
+deduce the local filename parameter if that is missing.}
+
+\docparam{vendorName}{The vendor name. If this is empty, it is assumed that
+no vendor name is wanted, if this is optional for the current config class.
+The vendor name is appended to the application name for wxRegConfig.}
+
+\docparam{localFilename}{Some config classes require a local filename. If this
+is not present, but required, the application name will be used instead.}
+
+\docparam{globalFilename}{Some config classes require a global filename. If
+this is not present, but required, the application name will be used instead.}
+
+\docparam{style}{Can be one of wxCONFIG\_USE\_LOCAL\_FILE and
+wxCONFIG\_USE\_GLOBAL\_FILE. The style interpretation depends on the config
+class and is ignored by some. For wxFileConfig, these styles determine whether
+a local or global config file is created or used. If the flag is present but
+the parameter is empty, the parameter will be set to a default. If the
+parameter is present but the style flag not, the relevant flag will be added
+to the style.}
+
+\wxheading{Remarks}
+
+By default, environment variable expansion is on and recording defaults is
+off.
+
+\membersection{wxConfigBase::\destruct{wxConfigBase}}\label{wxconfigbasedtor}
+
+\func{}{\destruct{wxConfigBase}}{\void}
+
+Empty but ensures that dtor of all derived classes is virtual.
+
+\membersection{wxConfigBase::Create}\label{wxconfigbasecreate}
+
+\func{static wxConfigBase *}{Create}{\void}
+
+Create a new config object: this function will create the "best"
+implementation of wxConfig available for the current platform, see comments
+near the definition of wxCONFIG\_WIN32\_NATIVE for details. It returns the
+created object and also sets it as the current one.
+
+\membersection{wxConfigBase::DontCreateOnDemand}\label{wxconfigbasedontcreateondemand}
+
+\func{void}{DontCreateOnDemand}{\void}
+
+Calling this function will prevent {\it Get()} from automatically creating a
+new config object if the current one is NULL. It might be useful to call it
+near the program end to prevent new config object "accidental" creation.
+
+\membersection{wxConfigBase::DeleteAll}\label{wxconfigbasedeleteall}
+
+\func{bool}{DeleteAll}{\void}
+
+Delete the whole underlying object (disk file, registry key, ...). Primarly
+for use by desinstallation routine.
+
+\membersection{wxConfigBase::DeleteEntry}\label{wxconfigbasedeleteentry}
+
+\func{bool}{DeleteEntry}{\param{const wxString\& }{ key}, \param{bool}{
+bDeleteGroupIfEmpty = TRUE}}
+
+Deletes the specified entry and the group it belongs to if it was the last key
+in it and the second parameter is true.
+
+\membersection{wxConfigBase::DeleteGroup}\label{wxconfigbasedeletegroup}
+
+\func{bool}{DeleteGroup}{\param{const wxString\& }{ key}}
+
+Delete the group (with all subgroups)
+
+\membersection{wxConfigBase::Exists}\label{wxconfigbaseexists}
+
+\constfunc{bool}{Exists}{\param{wxString\& }{strName}}
+
+returns TRUE if either a group or an entry with a given name exists
+
+\membersection{wxConfigBase::Flush}\label{wxconfigbaseflush}
+
+\func{bool}{Flush}{\param{bool }{bCurrentOnly = FALSE}}
+
+permanently writes all changes (otherwise, they're only written from object's
+destructor)
+
+\membersection{wxConfigBase::Get}\label{wxconfigbaseget}
+
+\func{wxConfigBase *}{Get}{\void}
+
+Get the current config object. If there is no current object, creates one
+(using {\it Create}) unless DontCreateOnDemand was called previously.
+
+\membersection{wxConfigBase::GetAppName}\label{wxconfigbasegetappname}
+
+\constfunc{wxString}{GetAppName}{\void}
+
+Returns the application name.
+
+\membersection{wxConfigBase::GetFirstGroup}\label{wxconfigbasegetfirstgroup}
+
+\constfunc{bool}{GetFirstGroup}{\param{wxString\& }{str}, \param{long\&}{
+index}}
+
+Gets the first group.
+
+\membersection{wxConfigBase::GetFirstEntry}\label{wxconfigbasegetfirstentry}
+
+\constfunc{bool}{GetFirstEntry}{\param{wxString\& }{str}, \param{long\&}{
+index}}
+
+Gets the first entry.
+
+\membersection{wxConfigBase::GetNextGroup}\label{wxconfigbasegetnextgroup}
+
+\constfunc{bool}{GetNextGroup}{\param{wxString\& }{str}, \param{long\&}{
+index}}
+
+Gets the next group.
+
+\membersection{wxConfigBase::GetNextEntry}\label{wxconfigbasegetnextentry}
+
+\constfunc{bool}{GetNextEntry}{\param{wxString\& }{str}, \param{long\&}{
+index}}
+
+Gets the next entry.
+
+\membersection{wxConfigBase::GetNumberOfEntries}\label{wxconfigbasegetnumberofentries}
+
+\constfunc{uint }{GetNumberOfEntries}{\param{bool }{bRecursive = FALSE}}
+
+\membersection{wxConfigBase::GetNumberOfGroups}\label{wxconfigbasegetnumberofgroups}
+
+\constfunc{uint}{GetNumberOfGroups}{\param{bool }{bRecursive = FALSE}}
+
+Get number of entries/subgroups in the current group, with or without its
+subgroups.
+
+\membersection{wxConfigBase::GetPath}\label{wxconfigbasegetpath}
+
+\constfunc{const wxString\&}{GetPath}{\void}
+
+Retrieve the current path (always as absolute path).
+
+\membersection{wxConfigBase::GetVendorName}\label{wxconfigbasegetvendorname}
+
+\constfunc{wxString}{GetVendorName}{\void}
+
+Returns the vendor name.
+
+\membersection{wxConfigBase::HasEntry}\label{wxconfigbasehasentry}
+
+\constfunc{bool}{HasEntry}{\param{wxString\& }{strName}}
+
+returns TRUE if the entry by this name exists
+
+\membersection{wxConfigBase::HasGroup}\label{wxconfigbasehasgroup}
+
+\constfunc{bool}{HasGroup}{\param{const wxString\& }{strName}}
+
+returns TRUE if the group by this name exists
+
+\membersection{wxConfigBase::IsExpandingEnvVars}\label{wxconfigbaseisexpandingenvvars}
+
+\constfunc{bool}{IsExpandingEnvVars}{\void}
+
+Returns TRUE if we are expanding environment variables in key values.
+
+\membersection{wxConfigBase::IsRecordingDefaults}\label{wxconfigbaseisrecordingdefaults}
+
+\func{bool}{IsRecordingDefaults}{\void} const
+
+Returns TRUE if we are writing defaults back to the config file.
+
+\membersection{wxConfigBase::Read}\label{wxconfigbaseread}
+
+\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{
+str}}
+
+Read a string from the key, returning TRUE if the value was read. If the key
+was not found, {\it str} is not changed.
+
+\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{
+str}, \param{const wxString\& }{defaultVal}}
+
+Read a string from the key. The default value is returned if the key was not
+found.
+
+Returns TRUE if value was really read, FALSE if the default was used.
+
+\constfunc{wxString}{Read}{\param{const wxString\& }{key}, \param{const
+wxString\& }{defaultVal}}
+
+Another version of {\it Read()}, returning the string value directly.
+
+\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l}}
+
+Reads a long value, returning TRUE if the value was found. If the value was
+not found, {\it l} is not changed.
+
+\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l},
+\param{long}{ defaultVal}}
+
+Reads a long value, returning TRUE if the value was found. If the value was
+not found, {\it defaultVal} is used instead.
+
+\constfunc{long }{Read}{\param{const wxString\& }{key}, \param{long}{
+defaultVal}}
+
+Reads a long value from the key and returns it. {\it defaultVal} is returned
+if the key is not found.
+
+NB: writing
+
+{\small \begin{verbatim} conf->Read("key", 0); \end{verbatim} }
+
+won't work because the call is ambiguous: compiler can not choose between two
+{\it Read} functions. Instead, write:
+
+{\small \begin{verbatim} conf->Read("key", 0l); \end{verbatim} }
+
+\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d}}
+
+Reads a double value, returning TRUE if the value was found. If the value was
+not found, {\it d} is not changed.
+
+\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d},
+ \param{double}{ defaultVal}}
+
+Reads a double value, returning TRUE if the value was found. If the value was
+not found, {\it defaultVal} is used instead.
+
+\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ b}}
+
+Reads a bool value, returning TRUE if the value was found. If the value was
+not found, {\it b} is not changed.
+
+\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ d},
+\param{bool}{ defaultVal}}
+
+Reads a bool value, returning TRUE if the value was found. If the value was
+not found, {\it defaultVal} is used instead.
+
+\membersection{wxConfigBase::Set}\label{wxconfigbaseset}
+
+\func{wxConfigBase *}{Set}{\param{wxConfigBase *}{pConfig}}
+
+Sets the config object as the current one, returns the pointer to the previous
+current object (both the parameter and returned value may be NULL)
+
+\membersection{wxConfigBase::SetAppName}\label{wxconfigbasesetappname}
+
+\func{void }{SetAppName}{\param{const wxString\&}{ appName}}
+
+Sets the application name.
+
+\membersection{wxConfigBase::SetExpandingEnvVars}\label{wxconfigbasesetexpandingenvvars}
+
+\func{void}{SetExpandEnvVars }{\param{bool }{bDoIt = TRUE}}
+
+Determine whether we wish to expand environment variables in key values.
+
+\membersection{wxConfigBase::SetPath}\label{wxconfigbasesetpath}
+
+\func{void}{SetPath}{\param{const wxString\& }{strPath}}
+
+Set current path: if the first character is '/', it's the absolute path,
+otherwise it's a relative path. '..' is supported. If the strPath doesn't
+exist it is created.
+
+\membersection{wxConfigBase::SetRecordDefaults}\label{wxconfigbasesetrecorddefaults}
+
+\func{void}{SetRecordDefaults}{\param{bool }{bDoIt = TRUE}}
+
+Sets whether defaults are written back to the config file.
+
+If on (default is off) all default values are written back to the config file.
+This allows the user to see what config options may be changed and is probably
+useful only for wxFileConfig.
+
+\membersection{wxConfigBase::SetVendorName}\label{wxconfigbasesetvendorname}
+
+\func{void}{SetVendorName}{\param{const wxString\&}{ vendorName}}
+
+Sets the vendor name.
+
+\membersection{wxConfigBase::Write}\label{wxconfigbasewrite}
+
+\func{bool}{Write}{\param{const wxString\& }{ key}, \param{const wxString\& }{
+value}}
+
+\func{bool}{Write}{\param{const wxString\& }{ key}, \param{long}{ value}}
+
+\func{bool}{Write}{\param{const wxString\& }{ key}, \param{double}{ value}}
+
+\func{bool}{Write}{\param{const wxString\& }{ key}, \param{bool}{ value}}
+
+These functions write the specified value to the config file and return TRUE
+on success.
+
+

docs/latex/wx/control.tex

@@ -0,0 +1,37 @@
+\section{\class{wxControl}}\label{wxcontrol}
+
+This is the base class for a control or `widget'.
+
+A control is generally a small window which processes user input and/or displays one or more item
+of data.
+
+\wxheading{Derived from}
+
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxValidator}{wxvalidator}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxControl::Command}\label{wxcontrolcommand}
+
+\func{void}{Command}{\param{wxCommandEvent\& }{event}}
+
+Simulates the effect of the user issuing a command to the item. See \helpref{wxCommandEvent}{wxcommandevent}.
+
+\membersection{wxControl::GetLabel}\label{wxcontrolgetlabel}
+
+\func{wxString\&}{GetLabel}{\void}
+
+Returns the control's text.
+
+\membersection{wxControl::SetLabel}\label{wxcontrolsetlabel}
+
+\func{void}{SetLabel}{\param{const wxString\& }{label}}
+
+Sets the item's text.
+

docs/latex/wx/cursor.tex

@@ -0,0 +1,169 @@
+\section{\class{wxCursor}}\label{wxcursor}
+
+A cursor is a small bitmap usually used for denoting where the mouse
+pointer is, with a picture that might indicate the interpretation of a
+mouse click. As with icons, cursors in X and MS Windows are created
+in a different manner. Therefore, separate cursors will be created for the
+different environments.  Platform-specific methods for creating a {\bf
+wxCursor} object are catered for, and this is an occasion where
+conditional compilation will probably be required (see \helpref{wxIcon}{wxicon} for
+an example).
+
+A single cursor object may be used in many windows (any subwindow type).
+The wxWindows convention is to set the cursor for a window, as in X,
+rather than to set it globally as in MS Windows, although a
+global \helpref{::wxSetCursor}{wxsetcursor} is also available for MS Windows use.
+
+\wxheading{Derived from}
+
+\helpref{wxBitmap}{wxbitmap}\\
+\helpref{wxGDIObject}{wxgdiobject}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxBitmap}{wxbitmap}, \helpref{wxIcon}{wxicon}, \helpref{wxWindow::SetCursor}{wxwindowsetcursor},\rtfsp
+\helpref{::wxSetCursor}{wxsetcursor}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCursor::wxCursor}\label{wxcursorconstr}
+
+\func{}{wxCursor}{\void}
+
+Default constructor.
+
+\func{}{wxCursor}{\param{const char}{ bits[]}, \param{int }{width},
+ \param{int }{ height}, \param{int }{hotSpotX=-1}, \param{int }{hotSpotY=-1}, \param{const char }{maskBits[]=NULL}}
+
+Constructs a cursor by passing an array of bits (Motif and Xt only). {\it maskBits} is used only under Motif.
+
+If either {\it hotSpotX} or {\it hotSpotY} is -1, the hotspot will be the centre of the cursor image (Motif only).
+
+\func{}{wxCursor}{\param{const wxString\& }{cursorName}, \param{long }{type}, \param{int }{hotSpotX=0}, \param{int }{hotSpotY=0}}
+
+Constructs a cursor by passing a string resource name or filename.
+
+{\it hotSpotX} and {\it hotSpotY} are currently only used under Windows when loading from an
+icon file, to specify the cursor hotspot relative to the top left of the image.
+
+\func{}{wxCursor}{\param{int}{ cursorId}}
+
+Constructs a cursor using a cursor identifier.
+
+\func{}{wxCursor}{\param{const wxCursor\&}{ cursor}}
+
+Copy constructor. This uses reference counting so is a cheap operation.
+
+\func{}{wxCursor}{\param{const wxCursor*}{ cursor}}
+
+Copy constructor. This uses reference counting so is a cheap operation.
+
+\wxheading{Parameters}
+
+\docparam{bits}{An array of bits.}
+
+\docparam{maskBits}{Bits for a mask bitmap.}
+
+\docparam{width}{Cursor width.}
+
+\docparam{height}{Cursor height.}
+
+\docparam{hotSpotX}{Hotspot x coordinate.}
+
+\docparam{hotSpotY}{Hotspot y coordinate.}
+
+\docparam{type}{Icon type to load. Under Motif, {\it type} defaults to {\bf wxBITMAP\_TYPE\_XBM}. Under Windows,
+it defaults to {\bf wxBITMAP\_TYPE\_CUR\_RESOURCE}.
+
+Under X, the permitted cursor types are:
+
+\twocolwidtha{6cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxBITMAP\_TYPE\_XBM}}{Load an X bitmap file.}
+\end{twocollist}
+
+Under Windows, the permitted types are:
+
+\twocolwidtha{6cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxBITMAP\_TYPE\_CUR}}{Load a cursor from a .cur cursor file (only if USE\_RESOURCE\_LOADING\_IN\_MSW
+is enabled in wx\_setup.h).}
+\twocolitem{\windowstyle{wxBITMAP\_TYPE\_CUR\_RESOURCE}}{Load a Windows resource (as specified in the .rc file).}
+\twocolitem{\windowstyle{wxBITMAP\_TYPE\_ICO}}{Load a cursor from a .ico icon file (only if USE\_RESOURCE\_LOADING\_IN\_MSW
+is enabled in wx\_setup.h). Specify {\it hotSpotX} and {\it hotSpotY}.}
+\end{twocollist}}
+
+\docparam{cursorId}{A stock cursor identifier. May be one of:
+
+\twocolwidtha{6cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxCURSOR\_ARROW}}{A standard arrow cursor.}
+\twocolitem{{\bf wxCURSOR\_BULLSEYE}}{Bullseye cursor.}
+\twocolitem{{\bf wxCURSOR\_CHAR}}{Rectangular character cursor.}
+\twocolitem{{\bf wxCURSOR\_CROSS}}{A cross cursor.}
+\twocolitem{{\bf wxCURSOR\_HAND}}{A hand cursor.}
+\twocolitem{{\bf wxCURSOR\_IBEAM}}{An I-beam cursor (vertical line).}
+\twocolitem{{\bf wxCURSOR\_LEFT\_BUTTON}}{Represents a mouse with the left button depressed.}
+\twocolitem{{\bf wxCURSOR\_MAGNIFIER}}{A magnifier icon.}
+\twocolitem{{\bf wxCURSOR\_MIDDLE\_BUTTON}}{Represents a mouse with the middle button depressed.}
+\twocolitem{{\bf wxCURSOR\_NO\_ENTRY}}{A no-entry sign cursor.}
+\twocolitem{{\bf wxCURSOR\_PAINT\_BRUSH}}{A paintbrush cursor.}
+\twocolitem{{\bf wxCURSOR\_PENCIL}}{A pencil cursor.}
+\twocolitem{{\bf wxCURSOR\_POINT\_LEFT}}{A cursor that points left.}
+\twocolitem{{\bf wxCURSOR\_POINT\_RIGHT}}{A cursor that points right.}
+\twocolitem{{\bf wxCURSOR\_QUESTION\_ARROW}}{An arrow and question mark.}
+\twocolitem{{\bf wxCURSOR\_RIGHT\_BUTTON}}{Represents a mouse with the right button depressed.}
+\twocolitem{{\bf wxCURSOR\_SIZENESW}}{A sizing cursor pointing NE-SW.}
+\twocolitem{{\bf wxCURSOR\_SIZENS}}{A sizing cursor pointing N-S.}
+\twocolitem{{\bf wxCURSOR\_SIZENWSE}}{A sizing cursor pointing NW-SE.}
+\twocolitem{{\bf wxCURSOR\_SIZEWE}}{A sizing cursor pointing W-E.}
+\twocolitem{{\bf wxCURSOR\_SIZING}}{A general sizing cursor.}
+\twocolitem{{\bf wxCURSOR\_SPRAYCAN}}{A spraycan cursor.}
+\twocolitem{{\bf wxCURSOR\_WAIT}}{A wait cursor.}
+\twocolitem{{\bf wxCURSOR\_WATCH}}{A watch cursor.}
+\end{twocollist}\twocolwidtha{5cm}
+
+Note that not all cursors are available on all platforms.}
+
+\docparam{cursor}{Pointer or reference to a cursor to copy.}
+
+\membersection{wxCursor::\destruct{wxCursor}}
+
+\func{}{\destruct{wxCursor}}{\void}
+
+Destroys the cursor. A cursor can be reused for more
+than one window, and does not get destroyed when the window is
+destroyed. wxWindows destroys all cursors on application exit, although
+it's best to clean them up explicitly.
+
+\membersection{wxCursor::Ok}\label{wxcursorok}
+
+\constfunc{bool}{Ok}{\void}
+
+Returns TRUE if cursor data is present.
+
+\membersection{wxCursor::operator $=$}\label{wxcursorassignment}
+
+\func{wxCursor\&}{operator $=$}{\param{const wxCursor\& }{cursor}}
+
+Assignment operator, using reference counting. Returns a reference
+to `this'.
+
+\membersection{wxCursor::operator $==$}\label{wxcursorequals}
+
+\func{bool}{operator $==$}{\param{const wxCursor\& }{cursor}}
+
+Equality operator. Two cursors are equal if they contain pointers
+to the same underlying cursor data. It does not compare each attribute,
+so two independently-created cursors using the same parameters will
+fail the test.
+
+\membersection{wxCursor::operator $!=$}\label{wxcursornotequals}
+
+\func{bool}{operator $!=$}{\param{const wxCursor\& }{cursor}}
+
+Inequality operator. Two cursors are not equal if they contain pointers
+to different underlying cursor data. It does not compare each attribute.
+
+

docs/latex/wx/database.tex

@@ -0,0 +1,272 @@
+\section{\class{wxDatabase}}\label{wxdatabase}
+
+Every database object represents an ODBC connection. The connection may be closed and reopened.
+
+\wxheading{Derivation}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\overview{wxDatabase overview}{wxdatabaseoverview}, \helpref{wxRecordSet}{wxrecordset}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDatabase::wxDatabase}
+
+\func{}{wxDatabase}{\void}
+
+Constructor. The constructor of the first wxDatabase instance of an
+application initializes the ODBC manager.
+
+\membersection{wxDatabase::\destruct{wxDatabase}}
+
+\func{}{\destruct{wxDatabase}}{\void}
+
+Destructor. Resets and destroys any associated wxRecordSet instances.
+
+The destructor of the last wxDatabase instance will deinitialize
+the ODBC manager.
+
+\membersection{wxDatabase::BeginTrans}
+
+\func{bool}{BeginTrans}{\void}
+
+Not implemented.
+
+\membersection{wxDatabase::Cancel}
+
+\func{void}{Cancel}{\void}
+
+Not implemented.
+
+\membersection{wxDatabase::CanTransact}
+
+\func{bool}{CanTransact}{\void}
+
+Not implemented.
+
+
+\membersection{wxDatabase::CanUpdate}
+
+\func{bool}{CanUpdate}{\void}
+
+Not implemented.
+
+\membersection{wxDatabase::Close}
+
+\func{bool}{Close}{\void}
+
+Resets the statement handles of any associated wxRecordSet objects,
+and disconnects from the current data source.
+
+\membersection{wxDatabase::CommitTrans}
+
+\func{bool}{CommitTrans}{\void}
+
+Commits previous transactions. Not implemented.
+
+\membersection{wxDatabase::ErrorOccured}
+
+\func{bool}{ErrorOccured}{\void}
+
+Returns TRUE if the last action caused an error.
+
+\membersection{wxDatabase::ErrorSnapshot}
+
+\func{void}{ErrorSnapshot}{\param{HSTMT}{ statement = SQL\_NULL\_HSTMT}}
+
+This function will be called whenever an ODBC error occured. It stores the
+error related information returned by ODBC. If a statement handle of the
+concerning ODBC action is available it should be passed to the function.
+
+\membersection{wxDatabase::GetDatabaseName}
+
+\func{wxString}{GetDatabaseName}{\void}
+
+Returns the name of the database associated with the current connection.
+
+\membersection{wxDatabase::GetDataSource}
+
+\func{wxString}{GetDataSource}{\void}
+
+Returns the name of the connected data source.
+
+\membersection{wxDatabase::GetErrorClass}
+
+\func{wxString}{GetErrorClass}{\void}
+
+Returns the error class of the last error. The error class consists of
+five characters where the first two characters contain the class
+and the other three characters contain the subclass of the ODBC error.
+See ODBC documentation for further details.
+
+\membersection{wxDatabase::GetErrorCode}
+
+\func{wxRETCODE}{GetErrorCode}{\void}
+
+Returns the error code of the last ODBC function call. This will be one of:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{SQL\_ERROR}{General error.}
+\twocolitem{SQL\_INVALID\_HANDLE}{An invalid handle was passed to an ODBC function.}
+\twocolitem{SQL\_NEED\_DATA}{ODBC expected some data.}
+\twocolitem{SQL\_NO\_DATA\_FOUND}{No data was found by this ODBC call.}
+\twocolitem{SQL\_SUCCESS}{The call was successful.}
+\twocolitem{SQL\_SUCCESS\_WITH\_INFO}{The call was successful, but further information can be
+obtained from the ODBC manager.}
+\end{twocollist}
+
+\membersection{wxDatabase::GetErrorMessage}
+
+\func{wxString}{GetErrorMessage}{\void}
+
+Returns the last error message returned by the ODBC manager.
+
+\membersection{wxDatabase::GetErrorNumber}
+
+\func{long}{GetErrorNumber}{\void}
+
+Returns the last native error. A native error is an ODBC driver dependent
+error number.
+
+\membersection{wxDatabase::GetHDBC}
+
+\func{HDBC}{GetHDBC}{\void}
+
+Returns the current ODBC database handle.
+
+\membersection{wxDatabase::GetHENV}
+
+\func{HENV}{GetHENV}{\void}
+
+Returns the ODBC environment handle. 
+
+\membersection{wxDatabase::GetInfo}
+
+\func{bool}{GetInfo}{\param{long}{ infoType}, \param{long *}{buf}}
+
+\func{bool}{GetInfo}{\param{long}{ infoType}, \param{const wxString\& }{buf}, \param{int}{ bufSize=-1}}
+
+Returns requested information. The return value is TRUE if successful, FALSE otherwise.
+
+{\it infoType} is an ODBC identifier specifying the type of information to be returned.
+
+{\it buf} is a character or long integer pointer to storage which must be allocated by the
+application, and which will contain the information if the function is successful.
+
+{\it bufSize} is the size of the character buffer. A value of -1 indicates that the size
+should be computed by the GetInfo function.
+
+\membersection{wxDatabase::GetPassword}
+
+\func{wxString}{GetPassword}{\void}
+
+Returns the password of the current user.
+
+\membersection{wxDatabase::GetUsername}
+
+\func{wxString}{GetUsername}{\void}
+
+Returns the current username.
+
+\membersection{wxDatabase::GetODBCVersionFloat}
+
+\func{float}{GetODBCVersionFloat}{\param{bool}{ implementation=TRUE}}
+
+Returns the version of ODBC in floating point format, e.g. 2.50.
+
+{\it implementation} should be TRUE to get the DLL version, or FALSE to get the
+version defined in the {\tt sql.h} header file.
+
+This function can return the value 0.0 if the header version number is not defined (for early
+versions of ODBC).
+
+\membersection{wxDatabase::GetODBCVersionString}
+
+\func{wxString}{GetODBCVersionString}{\param{bool}{ implementation=TRUE}}
+
+Returns the version of ODBC in string format, e.g. ``02.50".
+
+{\it implementation} should be TRUE to get the DLL version, or FALSE to get the
+version defined in the {\tt sql.h} header file.
+
+This function can return the value ``00.00" if the header version number is not defined (for early
+versions of ODBC).
+
+\membersection{wxDatabase::InWaitForDataSource}
+
+\func{bool}{InWaitForDataSource}{\void}
+
+Not implemented.
+
+\membersection{wxDatabase::IsOpen}
+
+\func{bool}{IsOpen}{\void}
+
+Returns TRUE if a connection is open.
+
+\membersection{wxDatabase::Open}\label{wxdatabaseopen}
+
+\func{bool}{Open}{\param{const wxString\& }{datasource}, \param{bool}{ exclusive = FALSE}, \param{bool }{readOnly = TRUE},
+ \param{const wxString\& }{username = ``ODBC"}, \param{const wxString\& }{password = ``"}}
+
+Connect to a data source. {\it datasource} contains the name of the ODBC data
+source. The parameters exclusive and readOnly are not used.
+
+\membersection{wxDatabase::OnSetOptions}
+
+\func{void}{OnSetOptions}{\param{wxRecordSet *}{recordSet}}
+
+Not implemented.  
+
+\membersection{wxDatabase::OnWaitForDataSource}
+
+\func{void}{OnWaitForDataSource}{\param{bool}{ stillExecuting}}
+
+Not implemented.
+
+\membersection{wxDatabase::RollbackTrans}
+
+\func{bool}{RollbackTrans}{\void}
+
+Sends a rollback to the ODBC driver. Not implemented.
+
+\membersection{wxDatabase::SetDataSource}
+
+\func{void}{SetDataSource}{\param{const wxString\& }{s}}
+
+Sets the name of the data source. Not implemented.
+
+\membersection{wxDatabase::SetLoginTimeout}
+
+\func{void}{SetLoginTimeout}{\param{long}{ seconds}}
+
+Sets the time to wait for an user login. Not implemented.
+
+\membersection{wxDatabase::SetPassword}
+
+\func{void}{SetPassword}{\param{const wxString\& }{s}}
+
+Sets the password of the current user. Not implemented.
+
+\membersection{wxDatabase::SetSynchronousMode}
+
+\func{void}{SetSynchronousMode}{\param{bool }{synchronous}}
+
+Toggles between synchronous and asynchronous mode. Currently only synchronous
+mode is supported, so this function has no effect.
+
+\membersection{wxDatabase::SetQueryTimeout}
+
+\func{void}{SetQueryTimeout}{\param{long}{ seconds}}
+
+Sets the time to wait for a response to a query. Not implemented.
+
+\membersection{wxDatabase::SetUsername}
+
+\func{void}{SetUsername}{\param{const wxString\& }{s}}
+
+Sets the name of the current user. Not implemented.
+
+

docs/latex/wx/date.tex

@@ -0,0 +1,348 @@
+\section{\class{wxDate}}\label{wxdate}
+
+A class for manipulating dates.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxTime}{wxtime}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDate::wxDate}\label{wxdateconstr}
+
+\func{}{wxDate}{\void}
+
+Default constructor.
+
+\func{}{wxDate}{\param{const wxDate\&}{ date}}
+
+Copy constructor.
+
+\func{}{wxDate}{\param{int}{ month}, \param{int}{ day}, \param{int}{ year}}
+
+Constructor taking month, day and year.
+
+\func{}{wxDate}{\param{long}{ julian}}
+
+Constructor taking an integer representing the Julian date. This is the number of days since
+1st January 4713 B.C., so to convert from the number of days since 1st January 1901,
+construct a date for 1/1/1901, and add the number of days.
+
+\func{}{wxDate}{\param{const wxString\& }{dateString}}
+
+Constructor taking a string representing a date. This must be either the string TODAY, or of the
+form {\tt MM/DD/YYYY} or {\tt MM-DD-YYYY}. For example:
+
+\begin{verbatim}
+  wxDate date("11/26/1966");
+\end{verbatim}
+
+\wxheading{Parameters}
+
+\docparam{date}{Date to copy.}
+
+\docparam{month}{Month: a number between 1 and 12.}
+
+\docparam{day}{Day: a number between 1 and 31.}
+
+\docparam{year}{Year, such as 1995, 2005.}
+
+\membersection{wxDate::\destruct{wxDate}}
+
+\func{void}{\destruct{wxDate}}{\void}
+
+Destructor.
+
+\membersection{wxDate::AddMonths}\label{wxdateaddmonths}
+
+\func{wxDate\&}{AddMonths}{\param{int}{ months=1}}
+
+Adds the given number of months to the date, returning a reference to `this'.
+
+\membersection{wxDate::AddWeeks}\label{wxdateaddweeks}
+
+\func{wxDate\&}{AddWeeks}{\param{int}{ weeks=1}}
+
+Adds the given number of weeks to the date, returning a reference to `this'.
+
+\membersection{wxDate::AddYears}\label{wxdateaddyears}
+
+\func{wxDate\&}{AddYears}{\param{int}{ years=1}}
+
+Adds the given number of months to the date, returning a reference to `this'.
+
+\membersection{wxDate::FormatDate}\label{wxdateformatdate}
+
+\constfunc{wxString}{FormatDate}{\param{int}{ type=-1}}
+
+Formats the date according to {\it type} if not -1, or according
+to the current display type if -1.
+
+\wxheading{Parameters}
+
+\docparam{type}{-1 or one of:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{wxDAY}{Format day only.}
+\twocolitem{wxMONTH}{Format month only.}
+\twocolitem{wxMDY}{Format MONTH, DAY, YEAR.}
+\twocolitem{wxFULL}{Format day, month and year in US style: DAYOFWEEK, MONTH, DAY, YEAR.}
+\twocolitem{wxEUROPEAN}{Format day, month and year in European style: DAY, MONTH, YEAR.}
+\end{twocollist}}
+
+\membersection{wxDate::GetDay}\label{wxdategetday}
+
+\constfunc{int}{GetDay}{\void}
+
+Returns the numeric day (in the range 1 to 31).
+
+\membersection{wxDate::GetDayOfWeek}\label{wxdategetdayofweek}
+
+\constfunc{int}{GetDayOfWeek}{\void}
+
+Returns the integer day of the week (in the range 1 to 7).
+
+\membersection{wxDate::GetDayOfWeekName}\label{wxdategetdayofweekname}
+
+\constfunc{wxString}{GetDayOfWeekName}{\void}
+
+Returns the name of the day of week.
+
+\membersection{wxDate::GetDayOfYear}\label{wxdategetdayofyear}
+
+\constfunc{long}{GetDayOfYear}{\void}
+
+Returns the day of the year (from 1 to 365).
+
+\membersection{wxDate::GetDaysInMonth}\label{wxdategetdaysinmonth}
+
+\constfunc{int}{GetDaysInMonth}{\void}
+
+Returns the number of days in the month (in the range 1 to 31).
+
+\membersection{wxDate::GetFirstDayOfMonth}\label{wxdategetfirstdayofmonth}
+
+\constfunc{int}{GetFirstDayOfMonth}{\void}
+
+Returns the day of week that is first in the month (in the range 1 to 7).
+
+\membersection{wxDate::GetJulianDate}\label{wxdategetjuliandate}
+
+\constfunc{long}{GetJulianDate}{\void}
+
+Returns the Julian date.
+
+\membersection{wxDate::GetMonth}\label{wxdategetmonth}
+
+\constfunc{int}{GetMonth}{\void}
+
+Returns the month number (in the range 1 to 12).
+
+\membersection{wxDate::GetMonthEnd}
+
+\func{wxDate}{GetMonthEnd}{\void}
+
+Returns the date representing the last day of the month.
+
+\membersection{wxDate::GetMonthName}\label{wxdategetmonthname}
+
+\constfunc{wxString}{GetMonthName}{\void}
+
+Returns the name of the month. Do not delete the returned storage.
+
+\membersection{wxDate::GetMonthStart}\label{wxdategetmonthstart}
+
+\constfunc{wxDate}{GetMonthStart}{\void}
+
+Returns the date representing the first day of the month.
+
+\membersection{wxDate::GetWeekOfMonth}\label{wxdategetweekofmonth}
+
+\constfunc{int}{GetWeekOfMonth}{\void}
+
+Returns the week of month (in the range 1 to 6).
+
+\membersection{wxDate::GetWeekOfYear}\label{wxdategetweekofyear}
+
+\constfunc{int}{GetWeekOfYear}{\void}
+
+Returns the week of year (in the range 1 to 52).
+
+\membersection{wxDate::GetYear}\label{wxdategetyear}
+
+\constfunc{int}{GetYear}{\void}
+
+Returns the year as an integer (such as `1995').
+
+\membersection{wxDate::GetYearEnd}\label{wxdategetyearend}
+
+\constfunc{wxDate}{GetYearEnd}{\void}
+
+Returns the date representing the last day of the year.
+
+\membersection{wxDate::GetYearStart}\label{wxdategetyearstart}
+
+\constfunc{wxDate}{GetYearStart}{\void}
+
+Returns the date representing the first day of the year.
+
+\membersection{wxDate::IsLeapYear}\label{wxdateisleapyear}
+
+\constfunc{bool}{IsLeapYear}{\void}
+
+Returns TRUE if the year of this date is a leap year.
+
+\membersection{wxDate::Set}\label{wxdateset}
+
+\func{wxDate\&}{Set}{\void}
+
+Sets the date to current system date, returning a reference to `this'.
+
+\func{wxDate\&}{Set}{\param{long}{ julian}}
+
+Sets the date to the given Julian date, returning a reference to `this'.
+
+\func{wxDate\&}{Set}{\param{int}{ month}, \param{int}{ day}, \param{int}{ year}}
+
+Sets the date to the given date, returning a reference to `this'.
+
+{\it month} is a number from 1 to 12.
+
+{\it day} is a number from 1 to 31.
+
+{\it year} is a year, such as 1995, 2005.
+
+\membersection{wxDate::SetFormat}\label{wxdatesetformat}
+
+\func{void}{SetFormat}{\param{int}{ format}}
+
+Sets the current format type.
+
+\wxheading{Parameters}
+
+\docparam{format}{-1 or one of:
+
+\twocolwidtha{5cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxDAY}}{Format day only.}
+\twocolitem{{\bf wxMONTH}}{Format month only.}
+\twocolitem{{\bf wxMDY}}{Format MONTH, DAY, YEAR.}
+\twocolitem{{\bf wxFULL}}{Format day, month and year in US style: DAYOFWEEK, MONTH, DAY, YEAR.}
+\twocolitem{{\bf wxEUROPEAN}}{Format day, month and year in European style: DAY, MONTH, YEAR.}
+\end{twocollist}}
+
+\membersection{wxDate::SetOption}\label{wxdatesetoption}
+
+\func{int}{SetOption}{\param{int}{ option}, \param{const bool}{ enable=TRUE}}
+
+Enables or disables an option for formatting.
+
+\wxheading{Parameters}
+
+\docparam{option}{May be one of:
+
+\twocolwidtha{5cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxNO\_CENTURY}}{The century is not formatted.}
+\twocolitem{{\bf wxDATE\_ABBR}}{Month and day names are abbreviated to 3 characters when formatting.}
+\end{twocollist}}
+
+\membersection{wxDate::operator wxString}\label{wxdatewxstring}
+
+\func{}{operator wxString}{\void}
+
+Conversion operator, to convert wxDate to wxString by calling FormatDate.
+
+\membersection{wxDate::operator $+$}\label{wxdateplus}
+
+\func{wxDate}{operator $+$}{\param{long}{ i}}
+
+\func{wxDate}{operator $+$}{\param{int}{ i}}
+
+Adds an integer number of days to the date, returning a date.
+
+\membersection{wxDate::operator $-$}\label{wxdateminus}
+
+\func{wxDate}{operator $-$}{\param{long}{ i}}
+
+\func{wxDate}{operator $-$}{\param{int}{ i}}
+
+Subtracts an integer number of days from the date, returning a date.
+
+\func{long}{operator $-$}{\param{const wxDate\&}{ date}}
+
+Subtracts one date from another, return the number of intervening days.
+
+\membersection{wxDate::operator $+=$}\label{wxdateplusequals}
+
+\func{wxDate\&}{operator $+=$}{\param{long}{ i}}
+
+Postfix operator: adds an integer number of days to the date, returning
+a reference to `this' date.
+
+\membersection{wxDate::operator $-=$}\label{wxdateminusequals}
+
+\func{wxDate\&}{operator $-=$}{\param{long}{ i}}
+
+Postfix operator: subtracts an integer number of days from the date, returning
+a reference to `this' date.
+
+\membersection{wxDate::operator $++$}\label{wxdateplusplus}
+
+\func{wxDate\&}{operator $++$}{\void}
+
+Increments the date (postfix or prefix).
+
+\membersection{wxDate::operator $--$}\label{wxdateminusminus}
+
+\func{wxDate\&}{operator $--$}{\void}
+
+Decrements the date (postfix or prefix).
+
+\membersection{wxDate::operator $<$}\label{wxdatelessthan}
+
+\func{friend bool}{operator $<$}{\param{const wxDate\&}{ date1}, \param{const wxDate\&}{ date2}}
+
+Function to compare two dates, returning TRUE if {\it date1} is earlier than {\it date2}.
+
+\membersection{wxDate::operator $<=$}\label{wxdatelessthaneq}
+
+\func{friend bool}{operator $<=$}{\param{const wxDate\&}{ date1}, \param{const wxDate\&}{ date2}}
+
+Function to compare two dates, returning TRUE if {\it date1} is earlier than or equal to {\it date2}.
+
+\membersection{wxDate::operator $>$}\label{wxdategreaterthan}
+
+\func{friend bool}{operator $>$}{\param{const wxDate\&}{ date1}, \param{const wxDate\&}{ date2}}
+
+Function to compare two dates, returning TRUE if {\it date1} is later than {\it date2}.
+
+\membersection{wxDate::operator $>=$}\label{wxdategreaterthaneq}
+
+\func{friend bool}{operator $>=$}{\param{const wxDate\&}{ date1}, \param{const wxDate\&}{ date2}}
+
+Function to compare two dates, returning TRUE if {\it date1} is later than or equal to {\it date2}.
+
+\membersection{wxDate::operator $==$}\label{wxdateequals}
+
+\func{friend bool}{operator $==$}{\param{const wxDate\&}{ date1}, \param{const wxDate\&}{ date2}}
+
+Function to compare two dates, returning TRUE if {\it date1} is equal to {\it date2}.
+
+\membersection{wxDate::operator $!=$}\label{wxdatenotequals}
+
+\func{friend bool}{operator $!=$}{\param{const wxDate\&}{ date1}, \param{const wxDate\&}{ date2}}
+
+Function to compare two dates, returning TRUE if {\it date1} is not equal to {\it date2}.
+
+\membersection{wxDate::operator \cinsert}\label{wxdateinsert}
+
+\func{friend ostream\&}{operator \cinsert}{\param{ostream\&}{ os}, \param{const wxDate\&}{ date}}
+
+Function to output a wxDate to an ostream.
+
+

docs/latex/wx/datstrm.tex

@@ -0,0 +1,114 @@
+\section{\class{wxDataStream}}\label{wxdatastream}
+
+This class provides functions that read and write integers or double in a
+portable way. So, a file written by an Intel processor can be read by a
+Sparc or anything else.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDataStream::wxDataStream}\label{wxdatastreamconstr}
+
+\func{}{wxDataStream}{\param{istream\&}{ stream}}
+
+Constructs a datastream object from a C++ input stream. Only read methods will
+be available.
+
+\wxheading{Parameters}
+
+\docparam{stream}{The C++ input stream.}
+
+\func{}{wxDataStream}{\param{istream\&}{ stream}}
+
+Constructs a datastream object from a C++ input stream. Only read methods will
+be available.
+
+\wxheading{Parameters}
+
+\docparam{stream}{The C++ input stream.}
+
+\membersection{wxDataStream::\destruct{wxDataStream}}
+
+\func{}{\destruct{wxDataStream}}{\void}
+
+Destroys the wxDataStream object.
+
+\membersection{wxDataStream::Read8}
+
+\func{unsigned char}{Read8}{\void}
+
+Reads a single byte from the stream.
+
+\membersection{wxDataStream::Read16}
+
+\func{unsigned short}{Read16}{\void}
+
+Reads a 16 bit integer from the stream.
+
+\membersection{wxDataStream::Read32}
+
+\func{unsigned long}{Read32}{\void}
+
+Reads a 32 bit integer from the stream.
+
+\membersection{wxDataStream::ReadDouble}
+
+\func{double}{ReadDouble}{\void}
+
+Reads a double (IEEE encoded) from the stream.
+
+\membersection{wxDataStream::ReadString}
+
+\func{wxString}{wxDataStream::ReadString}{\void}
+
+Reads a string from a stream. Actually, this function first reads a byte
+specifying the length of the string (without the last null character) and then
+reads the string.
+
+\membersection{wxDataStream::ReadLine}
+
+\func{wxString}{wxDataStream::ReadLine}{\void}
+
+Reads a line from the stream. A line is a string which ends with \\n or \\r\\n.
+
+\membersection{wxDataStream::Write8}
+
+\func{void}{wxDataStream::Write8}{{\param unsigned char }{i8}}
+
+Writes the single byte {\it i8} to the stream.
+
+\membersection{wxDataStream::Write16}
+
+\func{void}{wxDataStream::Write16}{{\param unsigned short }{i16}}
+
+Writes the 16 bit integer {\it i16} to the stream.
+
+\membersection{wxDataStream::Write32}
+
+\func{void}{wxDataStream::Write32}{{\param unsigned long }{i32}}
+
+Writes the 32 bit integer {\it i32} to the stream.
+
+\membersection{wxDataStream::WriteDouble}
+
+\func{void}{wxDataStream::WriteDouble}{{\param double }{f}}
+
+Writes the double {\it f} to the stream using the IEEE format.
+
+\membersection{wxDataStream::WriteString}
+
+\func{void}{wxDataStream::WriteString}{{\param const wxString\& }{string}}
+
+Writes {\it string} to the stream. Actually, this method writes the size of
+the string before writing {\it string} itself.
+
+\membersection{wxDataStream::WriteLine}
+
+\func{void}{wxDataStream::WriteLine}{{\param const wxString\& }{string}}
+
+Writes {\it string} as a line. Depending on the operating system, it adds
+\\n or \\r\\n.
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "referenc"
+%%% End: 

docs/latex/wx/dc.tex

@@ -0,0 +1,698 @@
+\section{\class{wxDC}}\label{wxdc}
+
+A wxDC is a {\it device context} onto which graphics and text can be drawn.
+It is intended to represent a number of output devices in a generic way,
+so a window can have a device context associated with it, and a printer also has a device context.
+In this way, the same piece of code may write to a number of different devices,
+if the device context is used as a parameter.
+
+Derived types of wxDC have documentation for specific features
+only, so refer to this section for most device context information.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Overview}{dcoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDC::wxDC}
+
+\func{}{wxDC}{\void}
+
+Constructor.
+
+\membersection{wxDC::\destruct{wxDC}}
+
+\func{}{\destruct{wxDC}}{\void}
+
+Destructor.
+
+\membersection{wxDC::BeginDrawing}\label{wxdcbegindrawing}
+
+\func{void}{BeginDrawing}{\void}
+
+Allows optimization of drawing code under MS Windows. Enclose
+drawing primitives between {\bf BeginDrawing} and {\bf EndDrawing}\rtfsp
+calls.
+
+Drawing to a wxDialog panel device context outside of a
+system-generated OnPaint event {\it requires} this pair of calls to
+enclose drawing code. This is because a Windows dialog box does not have
+a retained device context associated with it, and selections such as pen
+and brush settings would be lost if the device context were obtained and
+released for each drawing operation.
+
+\membersection{wxDC::Blit}\label{wxdcblit}
+
+\func{bool}{Blit}{\param{long}{ xdest}, \param{long}{ ydest}, \param{long}{ width}, \param{long}{ height},
+  \param{wxDC* }{source}, \param{long}{ xsrc}, \param{long}{ ysrc}, \param{int}{ logicalFunc},
+  \param{bool }{useMask}}
+
+Copy from a source DC to this DC, specifying the destination
+coordinates, size of area to copy, source DC, source coordinates, and
+logical function.
+
+\wxheading{Parameters}
+
+\docparam{xdest}{Destination device context x position.}
+
+\docparam{ydest}{Destination device context y position.}
+
+\docparam{width}{Width of source area to be copied.}
+
+\docparam{height}{Height of source area to be copied.}
+
+\docparam{source}{Source device context.}
+
+\docparam{xsrc}{Source device context x position.}
+
+\docparam{ysrc}{Source device context y position.}
+
+\docparam{logicalFunc}{Logical function to use: see \helpref{wxDC::SetLogicalFunction}{wxdcsetlogicalfunction}.}
+
+\docparam{useMask}{If TRUE, Blit does a transparent blit using the mask that is associated with the bitmap
+selected into the source device context. The Windows implementation does the following:
+
+\begin{enumerate}
+\item Creates a temporary bitmap and copies the destination area into it.
+\item Copies the source area into the temporary bitmap using the specified logical function.
+\item Sets the masked area in the temporary bitmap to BLACK by ANDing the
+mask bitmap with the temp bitmap with the foreground colour set to WHITE
+and the bg colour set to BLACK.
+\item Sets the unmasked area in the destination area to BLACK by ANDing the
+mask bitmap with the destination area with the foreground colour set to BLACK
+and the background colour set to WHITE.
+\item ORs the temporary bitmap with the destination area.
+\item Deletes the temporary bitmap.
+\end{enumerate}
+
+This sequence of operations ensures that the source's transparent area need not be black,
+and logical functions are supported.
+}
+
+\wxheading{Remarks}
+
+There is partial support for Blit in wxPostScriptDC, under X.
+
+See \helpref{wxMemoryDC}{wxmemorydc} for typical usage.
+
+wxheading{See also}
+
+\helpref{wxMemoryDC}{wxmemorydc}, \helpref{wxBitmap}{wxbitmap}, \helpref{wxMask}{wxmask}
+
+\membersection{wxDC::Clear}\label{wxdcclear}
+
+\func{void}{Clear}{\void}
+
+Clears the device context using the current background brush.
+
+\membersection{wxDC::CrossHair}\label{wxdccrosshair}
+
+\func{void}{CrossHair}{\param{long}{ x}, \param{long}{ y}}
+
+Displays a cross hair using the current pen. This is a vertical
+and horizontal line the height and width of the window, centred
+on the given point.
+
+\membersection{wxDC::DestroyClippingRegion}\label{wxdcdestroyclippingregion}
+
+\func{void}{DestroyClippingRegion}{\void}
+
+Destroys the current clipping region so that none of the DC is clipped.
+See also \helpref{wxDC::SetClippingRegion}{wxdcsetclippingregion}.
+
+\membersection{wxDC::DeviceToLogicalX}\label{wxdcdevicetologicalx}
+
+\func{long}{DeviceToLogicalX}{\param{long}{ x}}
+
+Convert device X coordinate to logical coordinate, using the current
+mapping mode.
+
+\membersection{wxDC::DeviceToLogicalXRel}\label{wxdcdevicetologicalxrel}
+
+\func{long}{DeviceToLogicalXRel}{\param{long}{ x}}
+
+Convert device X coordinate to relative logical coordinate, using the current
+mapping mode. Use this function for converting a width, for example.
+
+\membersection{wxDC::DeviceToLogicalY}\label{wxdcdevicetologicaly}
+
+\func{long}{DeviceToLogicalY}{\param{long}{ y}}
+
+Converts device Y coordinate to logical coordinate, using the current
+mapping mode.
+
+\membersection{wxDC::DeviceToLogicalYRel}\label{wxdcdevicetologicalyrel}
+
+\func{long}{DeviceToLogicalYRel}{\param{long}{ y}}
+
+Convert device Y coordinate to relative logical coordinate, using the current
+mapping mode. Use this function for converting a height, for example.
+
+\membersection{wxDC::DrawArc}\label{wxdcdrawarc}
+
+\func{void}{DrawArc}{\param{long}{ x1}, \param{long}{ y1}, \param{long}{ x2}, \param{long}{ y2}, \param{double}{ xc}, \param{double}{ yc}}
+
+Draws an arc of a circle, centred on ({\it xc, yc}), with starting point ({\it x1, y1})
+and ending at ({\it x2, y2}).   The current pen is used for the outline
+and the current brush for filling the shape.
+
+The arc is drawn in an anticlockwise direction from the start point to the end point.
+
+\membersection{wxDC::DrawEllipse}\label{wxdcdrawellipse}
+
+\func{void}{DrawEllipse}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}}
+
+Draws an ellipse contained in the rectangle with the given top left corner, and with the
+given size.  The current pen is used for the outline and the current brush for
+filling the shape.
+
+\membersection{wxDC::DrawEllipticArc}\label{wxdcdrawellipticarc}
+
+\func{void}{DrawEllipticArc}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height},
+ \param{double}{ start}, \param{double}{ end}}
+
+Draws an arc of an ellipse. The current pen is used for drawing the arc and 
+the current brush is used for drawing the pie. This function is currently only available for
+X window and PostScript device contexts.
+
+{\it x} and {\it y} specify the x and y coordinates of the upper-left corner of the rectangle that contains
+the ellipse.
+
+{\it width} and {\it height} specify the width and height of the rectangle that contains 
+the ellipse.
+
+{\it start} and {\it end} specify the start and end of the arc relative to the three-o'clock
+position from the center of the rectangle. Angles are specified
+in degrees (360 is a complete circle). Positive values mean
+counter-clockwise motion. If {\it start} is equal to {\it end}, a
+complete ellipse will be drawn.
+
+\membersection{wxDC::DrawIcon}\label{wxdcdrawicon}
+
+\func{void}{DrawIcon}{\param{const wxIcon\&}{ icon}, \param{long}{ x}, \param{long}{ y}}
+
+Draw an icon on the display (does nothing if the device context is PostScript).
+This can be the simplest way of drawing bitmaps on a window.
+
+\membersection{wxDC::DrawLine}\label{wxdcdrawline}
+
+\func{void}{DrawLine}{\param{long}{ x1}, \param{long}{ y1}, \param{long}{ x2}, \param{long}{ y2}}
+
+Draws a line from the first point to the second. The current pen is used
+for drawing the line.
+
+\membersection{wxDC::DrawLines}\label{wxdcdrawlines}
+
+\func{void}{DrawLines}{\param{int}{ n}, \param{wxPoint}{ points[]}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0}}
+
+\func{void}{DrawLines}{\param{wxList *}{points}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0}}
+
+Draws lines using an array of {\it points} of size {\it n}, or list of
+pointers to points, adding the optional offset coordinate. The current
+pen is used for drawing the lines.  The programmer is responsible for
+deleting the list of points.
+
+\membersection{wxDC::DrawPolygon}\label{wxdcdrawpolygon}
+
+\func{void}{DrawPolygon}{\param{int}{ n}, \param{wxPoint}{ points[]}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0},\\
+  \param{int }{fill\_style = wxODDEVEN\_RULE}}
+
+\func{void}{DrawPolygon}{\param{wxList *}{points}, \param{long}{ xoffset = 0}, \param{long}{ yoffset = 0},\\
+  \param{int }{fill\_style = wxODDEVEN\_RULE}}
+
+Draws a filled polygon using an array of {\it points} of size {\it n},
+or list of pointers to points, adding the optional offset coordinate.
+
+The last argument specifies the fill rule: {\bf wxODDEVEN\_RULE} (the
+default) or {\bf wxWINDING\_RULE}.
+
+The current pen is used for drawing the outline, and the current brush
+for filling the shape.  Using a transparent brush suppresses filling.
+The programmer is responsible for deleting the list of points.
+
+Note that wxWindows automatically closes the first and last points.
+
+\membersection{wxDC::DrawPoint}\label{wxdcdrawpoint}
+
+\func{void}{DrawPoint}{\param{long}{ x}, \param{long}{ y}}
+
+Draws a point using the current pen.
+
+\membersection{wxDC::DrawRectangle}\label{wxdcdrawrectangle}
+
+\func{void}{DrawRectangle}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}}
+
+Draws a rectangle with the given top left corner, and with the given
+size.  The current pen is used for the outline and the current brush
+for filling the shape.
+
+\membersection{wxDC::DrawRoundedRectangle}\label{wxdcdrawroundedrectangle}
+
+\func{void}{DrawRoundedRectangle}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}, \param{double}{ radius = 20}}
+
+Draws a rectangle with the given top left corner, and with the given
+size.  The corners are quarter-circles using the given radius. The
+current pen is used for the outline and the current brush for filling
+the shape.
+
+If {\it radius} is positive, the value is assumed to be the
+radius of the rounded corner. If {\it radius} is negative,
+the absolute value is assumed to be the {\it proportion} of the smallest
+dimension of the rectangle. This means that the corner can be
+a sensible size relative to the size of the rectangle, and also avoids
+the strange effects X produces when the corners are too big for
+the rectangle.
+
+\membersection{wxDC::DrawSpline}\label{wxdcdrawspline}
+
+\func{void}{DrawSpline}{\param{wxList *}{points}}
+
+Draws a spline between all given control points, using the current
+pen.  Doesn't delete the wxList and contents. The spline is drawn
+using a series of lines, using an algorithm taken from the X drawing
+program `XFIG'.
+
+\func{void}{DrawSpline}{\param{long}{ x1}, \param{long}{ y1}, \param{long}{ x2}, \param{long}{ y2}, \param{long}{ x3}, \param{long}{ y3}}
+
+Draws a three-point spline using the current pen.
+
+\membersection{wxDC::DrawText}\label{wxdcdrawtext}
+
+\func{void}{DrawText}{\param{const wxString\& }{text}, \param{long}{ x}, \param{long}{ y}}
+
+Draws a text string at the specified point, using the current text font,
+and the current text foreground and background colours.
+
+The coordinates refer to the top-left corner of the rectangle bounding
+the string. See \helpref{wxDC::GetTextExtent}{wxdcgettextextent} for how
+to get the dimensions of a text string, which can be used to position the
+text more precisely.
+
+\membersection{wxDC::EndDoc}\label{wxdcenddoc}
+
+\func{void}{EndDoc}{\void}
+
+Ends a document (only relevant when outputting to a printer).
+
+\membersection{wxDC::EndDrawing}\label{wxdcenddrawing}
+
+\func{void}{EndDrawing}{\void}
+
+Allows optimization of drawing code under MS Windows. Enclose
+drawing primitives between {\bf BeginDrawing} and {\bf EndDrawing}\rtfsp
+calls.
+
+\membersection{wxDC::EndPage}\label{wxdcendpage}
+
+\func{void}{EndPage}{\void}
+
+Ends a document page (only relevant when outputting to a printer).
+
+\membersection{wxDC::FloodFill}\label{wxdcfloodfill}
+
+\func{void}{FloodFill}{\param{long}{ x}, \param{long}{ y}, \param{wxColour *}{colour}, \param{int}{ style=wxFLOOD\_SURFACE}}
+
+Flood fills the device context starting from the given point, in the given colour,
+and using a style:
+
+\begin{itemize}\itemsep=0pt
+\item wxFLOOD\_SURFACE: the flooding occurs until a colour other than the given colour is encountered.
+\item wxFLOOD\_BORDER: the area to be flooded is bounded by the given colour.
+\end{itemize}
+
+{\it Note:} this function is available in MS Windows only.
+
+\membersection{wxDC::GetBackground}\label{wxdcgetbackground}
+
+\func{wxBrush *}{GetBackground}{\void}
+
+Gets the brush used for painting the background (see \helpref{wxDC::SetBackground}{wxdcsetbackground}).
+
+\membersection{wxDC::GetBrush}\label{wxdcgetbrush}
+
+\func{wxBrush *}{GetBrush}{\void}
+
+Gets the current brush (see \helpref{wxDC::SetBrush}{wxdcsetbrush}).
+
+\membersection{wxDC::GetCharHeight}\label{wxdcgetcharheight}
+
+\func{long}{GetCharHeight}{\void}
+
+Gets the character height of the currently set font.
+
+\membersection{wxDC::GetCharWidth}\label{wxdcgetcharwidth}
+
+\func{long}{GetCharWidth}{\void}
+
+Gets the average character width of the currently set font.
+
+\membersection{wxDC::GetClippingBox}\label{wxdcgetclippingbox}
+
+\func{void}{GetClippingBox}{\param{long}{ *x}, \param{long}{ *y}, \param{long}{ *width}, \param{long}{ *height}}
+
+Gets the rectangle surrounding the current clipping region.
+
+\membersection{wxDC::GetFont}\label{wxdcgetfont}
+
+\func{wxFont *}{GetFont}{\void}
+
+Gets the current font (see \helpref{wxDC::SetFont}{wxdcsetfont}).
+
+\membersection{wxDC::GetLogicalFunction}\label{wxdcgetlogicalfunction}
+
+\func{int}{GetLogicalFunction}{\void}
+
+Gets the current logical function (see \helpref{wxDC::SetLogicalFunction}{wxdcsetlogicalfunction}).
+
+\membersection{wxDC::GetMapMode}\label{wxdcgetmapmode}
+
+\func{int}{GetMapMode}{\void}
+
+Gets the {\it mapping mode} for the device context (see \helpref{wxDC::SetMapMode}{wxdcsetmapmode}).
+
+\membersection{wxDC::GetOptimization}\label{wxdcgetoptimization}
+
+\func{bool}{GetOptimization}{\void}
+
+Returns TRUE if device context optimization is on.
+See \helpref{wxDC::SetOptimization}{wxsetoptimization} for details.
+
+\membersection{wxDC::GetPen}\label{wxdcgetpen}
+
+\func{wxPen *}{GetPen}{\void}
+
+Gets the current pen (see \helpref{wxDC::SetPen}{wxdcsetpen}).
+
+\membersection{wxDC::GetPixel}\label{wxdcgetpixel}
+
+\func{bool}{GetPixel}{\param{long}{ x}, \param{long}{ y}, \param{wxColour *}{colour}}
+
+Sets {\it colour} to the colour at the specified location. Windows only; an X implementation
+is being worked on. Not available for wxPostScriptDC or wxMetaFileDC.
+
+\membersection{wxDC::GetSize}\label{wxdcgetsize}
+
+\func{void}{GetSize}{\param{long *}{width}, \param{long *}{height}}
+
+For a PostScript device context, this gets the maximum size of graphics
+drawn so far on the device context.
+
+For a Windows printer device context, this gets the horizontal and vertical
+resolution. It can be used to scale graphics to fit the page when using
+a Windows printer device context. For example, if {\it maxX} and {\it maxY}\rtfsp
+represent the maximum horizontal and vertical `pixel' values used in your
+application, the following code will scale the graphic to fit on the
+printer page:
+
+\begin{verbatim}
+  long w, h;
+  dc.GetSize(&w, &h);
+  double scaleX=(double)(maxX/w);
+  double scaleY=(double)(maxY/h);
+  dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY));
+\end{verbatim}
+
+\membersection{wxDC::GetTextBackground}\label{wxdcgettextbackground}
+
+\func{wxColour\&}{GetTextBackground}{\void}
+
+Gets the current text background colour (see \helpref{wxDC::SetTextBackground}{wxdcsettextbackground}).
+
+\membersection{wxDC::GetTextExtent}\label{wxdcgettextextent}
+
+\func{void}{GetTextExtent}{\param{const wxString\& }{string}, \param{long *}{w}, \param{long *}{h},\\
+  \param{long *}{descent = NULL}, \param{long *}{externalLeading = NULL}, \param{wxFont *}{font = NULL}}
+
+Gets the dimensions of the string using the currently selected font.
+\rtfsp{\it string} is the text string to measure, {\it w} and {\it h} are
+the total width and height respectively, {\it descent} is the
+dimension from the baseline of the font to the bottom of the
+descender, and {\it externalLeading} is any extra vertical space added
+to the font by the font designer (usually is zero).
+
+The optional parameter {\it font} specifies an alternative
+to the currently selected font: but note that this does not
+yet work under Windows, so you need to set a font for
+the device context first.
+
+See also \helpref{wxFont}{wxfont}, \helpref{wxDC::SetFont}{wxdcsetfont}.
+
+\membersection{wxDC::GetTextForeground}\label{wxdcgettextforeground}
+
+\func{wxColour\&}{GetTextForeground}{\void}
+
+Gets the current text foreground colour (see \helpref{wxDC::SetTextForeground}{wxdcsettextforeground}).
+
+\membersection{wxDC::LogicalToDeviceX}\label{wxdclogicaltodevicex}
+
+\func{long}{LogicalToDeviceX}{\param{long}{ x}}
+
+Converts logical X coordinate to device coordinate, using the current
+mapping mode.
+
+\membersection{wxDC::LogicalToDeviceXRel}\label{wxdclogicaltodevicexrel}
+
+\func{long}{LogicalToDeviceXRel}{\param{long}{ x}}
+
+Converts logical X coordinate to relative device coordinate, using the current
+mapping mode. Use this for converting a width, for example.
+
+\membersection{wxDC::LogicalToDeviceY}\label{wxdclogicaltodevicey}
+
+\func{long}{LogicalToDeviceY}{\param{long}{ y}}
+
+Converts logical Y coordinate to device coordinate, using the current
+mapping mode.
+
+\membersection{wxDC::LogicalToDeviceYRel}\label{wxdclogicaltodeviceyrel}
+
+\func{long}{LogicalToDeviceYRel}{\param{long}{ y}}
+
+Converts logical Y coordinate to relative device coordinate, using the current
+mapping mode. Use this for converting a height, for example.
+
+\membersection{wxDC::MaxX}\label{wxdcmaxx}
+
+\func{long}{MaxX}{\void}
+
+Gets the maximum horizontal extent used in drawing commands so far.
+
+\membersection{wxDC::MaxY}\label{wxdcmaxy}
+
+\func{long}{MaxY}{\void}
+
+Gets the maximum vertical extent used in drawing commands so far.
+
+\membersection{wxDC::MinX}\label{wxdcminx}
+
+\func{long}{MinX}{\void}
+
+Gets the minimum horizontal extent used in drawing commands so far.
+
+\membersection{wxDC::MinY}\label{wxdcminy}
+
+\func{long}{MinY}{\void}
+
+Gets the minimum vertical extent used in drawing commands so far.
+
+\membersection{wxDC::Ok}\label{wxdcok}
+
+\func{bool}{Ok}{\void}
+
+Returns TRUE if the DC is ok to use.
+
+\membersection{wxDC::SetDeviceOrigin}\label{wxdcsetdeviceorigin}
+
+\func{void}{SetDeviceOrigin}{\param{long}{ x}, \param{long}{ y}}
+
+Sets the device origin (i.e., the origin in pixels after scaling has been
+applied).
+
+This function may be useful in Windows printing
+operations for placing a graphic on a page.
+
+\membersection{wxDC::SetBackground}\label{wxdcsetbackground}
+
+\func{void}{SetBackground}{\param{const wxBrush\& }{brush}}
+
+Sets the current background brush for the DC.
+
+\membersection{wxDC::SetBackgroundMode}\label{wxdcsetbackgroundmode}
+
+\func{void}{SetBackgroundMode}{\param{int}{ mode}}
+
+{\it mode} may be one of wxSOLID and wxTRANSPARENT. This setting determines
+whether text will be drawn with a background colour or not.
+
+\membersection{wxDC::SetClippingRegion}\label{wxdcsetclippingregion}
+
+\func{void}{SetClippingRegion}{\param{long}{ x}, \param{long}{ y}, \param{long}{ width}, \param{long}{ height}}
+
+Sets the clipping region for the DC. The clipping region is a rectangular area
+to which drawing is restricted.  Possible uses for the clipping region are for clipping text
+or for speeding up window redraws when only a known area of the screen is damaged.
+
+See also \helpref{wxDC::DestroyClippingRegion}{wxdcdestroyclippingregion}.
+
+\membersection{wxDC::SetPalette}\label{wxdcsetpalette}
+
+\func{void}{SetPalette}{\param{const wxPalette\& }{palette}}
+
+If this is a window DC or memory DC, assigns the given palette to the window
+or bitmap associated with the DC. If the argument is wxNullPalette, the current
+palette is selected out of the device context, and the original palette
+restored.
+
+See \helpref{wxPalette}{wxpalette} for further details.
+
+\membersection{wxDC::SetBrush}\label{wxdcsetbrush}
+
+\func{void}{SetBrush}{\param{const wxBrush\& }{brush}}
+
+Sets the current brush for the DC.
+
+If the argument is wxNullBrush, the current brush is selected out of the device
+context, and the original brush restored, allowing the current brush to
+be destroyed safely.
+
+See also \helpref{wxBrush}{wxbrush}.
+
+\membersection{wxDC::SetFont}\label{wxdcsetfont}
+
+\func{void}{SetFont}{\param{const wxFont\& }{font}}
+
+Sets the current font for the DC.
+
+If the argument is wxNullFont, the current font is selected out of the device
+context, and the original font restored, allowing the current font to
+be destroyed safely.
+
+See also \helpref{wxFont}{wxfont}.
+
+\membersection{wxDC::SetLogicalFunction}\label{wxdcsetlogicalfunction}
+
+\func{void}{SetLogicalFunction}{\param{int}{ function}}
+
+Sets the current logical function for the device context.  This determines how
+a source pixel (from a pen or brush colour, or source device context if
+using \helpref{wxDC::Blit}{wxdcblit}) combines with a destination pixel in the
+current device context.
+
+The possible values
+and their meaning in terms of source and destination pixel values are
+as follows:
+
+\begin{verbatim}
+wxAND                 src AND dst
+wxAND_INVERT          (NOT src) AND dst
+wxAND_REVERSE         src AND (NOT dst)
+wxCLEAR               0
+wxCOPY                src
+wxEQUIV               (NOT src) XOR dst
+wxINVERT              NOT dst
+wxNAND                (NOT src) OR (NOT dst)
+wxNOR                 (NOT src) AND (NOT dst)
+wxNO_OP               dst
+wxOR                  src OR dst
+wxOR_INVERT           (NOT src) OR dst
+wxOR_REVERSE          src OR (NOT dst)
+wxSET                 1
+wxSRC_INVERT          NOT src
+wxXOR                 src XOR dst
+\end{verbatim}
+
+The default is wxCOPY, which simply draws with the current colour.
+The others combine the current colour and the background using a
+logical operation.  wxXOR is commonly used for drawing rubber bands or
+moving outlines, since drawing twice reverts to the original colour.
+
+\membersection{wxDC::SetMapMode}\label{wxdcsetmapmode}
+
+\func{void}{SetMapMode}{\param{int}{ int}}
+
+The {\it mapping mode} of the device context defines the unit of
+measurement used to convert logical units to device units. Note that
+in X, text drawing isn't handled consistently with the mapping mode; a
+font is always specified in point size. However, setting the {\it
+user scale} (see \helpref{wxDC::SetUserScale}{wxdcsetuserscale}) scales the text appropriately. In
+Windows, scaleable TrueType fonts are always used; in X, results depend
+on availability of fonts, but usually a reasonable match is found.
+
+Note that the coordinate origin should ideally be selectable, but for
+now is always at the top left of the screen/printer.
+
+Drawing to a Windows printer device context under UNIX
+uses the current mapping mode, but mapping mode is currently ignored for
+PostScript output.
+
+The mapping mode can be one of the following:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{MM\_TWIPS}{Each logical unit is 1/20 of a point, or 1/1440 of
+  an inch.}
+\twocolitem{MM\_POINTS}{Each logical unit is a point, or 1/72 of an inch.}
+\twocolitem{MM\_METRIC}{Each logical unit is 1 mm.}
+\twocolitem{MM\_LOMETRIC}{Each logical unit is 1/10 of a mm.}
+\twocolitem{MM\_TEXT}{Each logical unit is 1 pixel.}
+\end{twocollist}
+
+\membersection{wxDC::SetOptimization}\label{wxsetoptimization}
+
+\func{void}{SetOptimization}{\param{bool }{optimize}}
+
+If {\it optimize} is TRUE (the default), this function sets optimization mode on.
+This currently means that under X, the device context will not try to set a pen or brush
+property if it is known to be set already. This approach can fall down
+if non-wxWindows code is using the same device context or window, for example
+when the window is a panel on which the windowing system draws panel items.
+The wxWindows device context 'memory' will now be out of step with reality.
+
+Setting optimization off, drawing, then setting it back on again, is a trick
+that must occasionally be employed.
+
+\membersection{wxDC::SetPen}\label{wxdcsetpen}
+
+\func{void}{SetPen}{\param{const wxPen\& }{pen}}
+
+Sets the current pen for the DC.
+
+If the argument is wxNullPen, the current pen is selected out of the device
+context, and the original pen restored.
+
+\membersection{wxDC::SetTextBackground}\label{wxdcsettextbackground}
+
+\func{void}{SetTextBackground}{\param{const wxColour\& }{colour}}
+
+Sets the current text background colour for the DC.
+
+\membersection{wxDC::SetTextForeground}\label{wxdcsettextforeground}
+
+\func{void}{SetTextForeground}{\param{const wxColour\& }{colour}}
+
+Sets the current text foreground colour for the DC.
+
+\membersection{wxDC::SetUserScale}\label{wxdcsetuserscale}
+
+\func{void}{SetUserScale}{\param{double}{ xScale}, \param{double}{ yScale}}
+
+Sets the user scaling factor, useful for applications which require
+`zooming'.
+
+\membersection{wxDC::StartDoc}\label{wxdcstartdoc}
+
+\func{bool}{StartDoc}{\param{const wxString\& }{message}}
+
+Starts a document (only relevant when outputting to a printer).
+Message is a message to show whilst printing.
+
+\membersection{wxDC::StartPage}\label{wxdcstartpage}
+
+\func{bool}{StartPage}{\void}
+
+Starts a document page (only relevant when outputting to a printer).
+

docs/latex/wx/ddeclint.tex

@@ -0,0 +1,67 @@
+\section{\class{wxDDEClient}}\label{wxddeclient}
+
+\overview{Interprocess communications overview}{ipcoverview}
+
+A wxDDEClient object represents the client part of a client-server DDE
+(Dynamic Data Exchange) conversation (available in {\it both}\/
+Windows and UNIX).
+
+To create a client which can communicate with a suitable server,
+you need to derive a class from wxDDEConnection and another from wxDDEClient.
+The custom wxDDEConnection class will intercept communications in
+a `conversation' with a server, and the custom wxDDEServer is required
+so that a user-overriden \helpref{wxDDEClient::OnMakeConnection}{wxddeclientonmakeconnection} member can return
+a wxDDEConnection of the required class, when a connection is made.
+
+\wxheading{Derived from}
+
+wxDDEObject
+
+\wxheading{See also}
+
+\helpref{wxDDEServer}{wxddeserver}, \helpref{wxDDEConnection}{wxddeconnection},
+the chapter on interprocess communication in the user manual, and
+the programs in {\tt samples/ipc}.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDDEClient::wxDDEClient}
+
+\func{}{wxDDEClient}{\void}
+
+Constructs a client object.
+
+\membersection{wxDDEClient::MakeConnection}\label{wxddeclientmakeconnection}
+
+\func{wxDDEConnection *}{MakeConnection}{\param{const wxString\& }{host}, \param{const wxString\& }{service}, \param{const wxString\& }{topic}}
+
+Tries to make a connection with a server specified by the host
+(machine name under UNIX, ignored under Windows), service name (must
+contain an integer port number under UNIX), and topic string. If the
+server allows a connection, a wxDDEConnection object will be returned.
+The type of wxDDEConnection returned can be altered by overriding
+the \helpref{wxDDEClient::OnMakeConnection}{wxddeclientonmakeconnection} member to return your own
+derived connection object.
+
+\membersection{wxDDEClient::OnMakeConnection}\label{wxddeclientonmakeconnection}
+
+\func{wxDDEConnection *}{OnMakeConnection}{\void}
+
+The type of \helpref{wxDDEConnection}{wxddeconnection} returned from a \helpref{wxDDEClient::MakeConnection}{wxddeclientmakeconnection} call can
+be altered by deriving the {\bf OnMakeConnection} member to return your
+own derived connection object. By default, an ordinary wxDDEConnection
+object is returned.
+
+The advantage of deriving your own connection class is that it will
+enable you to intercept messages initiated by the server, such
+as \helpref{wxDDEConnection::OnAdvise}{wxddeconnectiononadvise}. You may also want to
+store application-specific data in instances of the new class.
+
+\membersection{wxDDEClient::ValidHost}
+
+\func{bool}{ValidHost}{\param{const wxString\& }{host}}
+
+Returns TRUE if this is a valid host name, FALSE otherwise. This always
+returns TRUE under MS Windows.
+
+

docs/latex/wx/ddeconn.tex

@@ -0,0 +1,166 @@
+\section{\class{wxDDEConnection}}\label{wxddeconnection}
+
+A wxDDEConnection object represents the connection between a client and a
+server. It can be created by making a connection using a\rtfsp
+\helpref{wxDDEClient}{wxddeclient} object, or by the acceptance of a connection by a\rtfsp
+\helpref{wxDDEServer}{wxddeserver} object. The bulk of a DDE (Dynamic Data Exchange)
+conversation (available in both Windows and UNIX) is controlled by
+calling members in a {\bf wxDDEConnection} object or by overriding its
+members.
+
+An application should normally derive a new connection class from
+wxDDEConnection, in order to override the communication event handlers
+to do something interesting.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxDDEClient}{wxddeclient}, \helpref{wxDDEServer}{wxddeserver}, \helpref{Interprocess communications overview}{ipcoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDDEConnection::wxDDEConnection}
+
+\func{}{wxDDEConnection}{\void}
+
+\func{}{wxDDEConnection}{\param{char* }{buffer}, \param{int}{ size}}
+
+Constructs a connection object. If no user-defined connection object is
+to be derived from wxDDEConnection, then the constructor should not be
+called directly, since the default connection object will be provided on
+requesting (or accepting) a connection. However, if the user defines his
+or her own derived connection object, the \helpref{wxDDEServer::OnAcceptConnection}{wxddeserveronacceptconnection}\rtfsp
+and/or \helpref{wxDDEClient::OnMakeConnection}{wxddeclientonmakeconnection} members should be replaced by
+functions which construct the new connection object. If the arguments of
+the wxDDEConnection constructor are void, then a default buffer is
+associated with the connection. Otherwise, the programmer must provide a
+a buffer and size of the buffer for the connection object to use in
+transactions.
+
+\membersection{wxDDEConnection::Advise}
+
+\func{bool}{Advise}{\param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size = -1}, \param{int}{ format = wxCF\_TEXT}}
+
+Called by the server application to advise the client of a change in
+the data associated with the given item. Causes the client
+connection's \helpref{wxDDEConnection::OnAdvise}{wxddeconnectiononadvise}
+member to be called. Returns TRUE if successful.
+
+\membersection{wxDDEConnection::Execute}
+
+\func{bool}{Execute}{\param{char* }{data}, \param{int}{ size = -1},
+\param{int}{ format = wxCF\_TEXT}}
+
+Called by the client application to execute a command on the server. Can
+also be used to transfer arbitrary data to the server (similar
+to \helpref{wxDDEConnection::Poke}{wxddeconnectionpoke} in that respect). Causes the
+server connection's \helpref{wxDDEConnection::OnExecute}{wxddeconnectiononexecute} member to be
+called. Returns TRUE if successful.
+
+\membersection{wxDDEConnection::Disconnect}
+
+\func{bool}{Disconnect}{\void}
+
+Called by the client or server application to disconnect from the other
+program; it causes the \helpref{wxDDEConnection::OnDisconnect}{wxddeconnectionondisconnect} message
+to be sent to the corresponding connection object in the other
+program. The default behaviour of {\bf OnDisconnect} is to delete the
+connection, but the calling application must explicitly delete its
+side of the connection having called {\bf Disconnect}. Returns TRUE if
+successful.
+
+\membersection{wxDDEConnection::OnAdvise}\label{wxddeconnectiononadvise}
+
+\func{bool}{OnAdvise}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size}, \param{int}{ format}}
+
+Message sent to the client application when the server notifies it of a
+change in the data associated with the given item.
+
+\membersection{wxDDEConnection::OnDisconnect}\label{wxddeconnectionondisconnect}
+
+\func{bool}{OnDisconnect}{\void}
+
+Message sent to the client or server application when the other
+application notifies it to delete the connection. Default behaviour is
+to delete the connection object.
+
+\membersection{wxDDEConnection::OnExecute}\label{wxddeconnectiononexecute}
+
+\func{bool}{OnExecute}{\param{const wxString\& }{topic}, \param{char* }{data}, \param{int}{ size}, \param{int}{ format}}
+
+Message sent to the server application when the client notifies it to
+execute the given data. Note that there is no item associated with
+this message.
+
+\membersection{wxDDEConnection::OnPoke}\label{wxddeconnectiononpoke}
+
+\func{bool}{OnPoke}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size}, \param{int}{ format}}
+
+Message sent to the server application when the client notifies it to
+accept the given data.
+
+\membersection{wxDDEConnection::OnRequest}\label{wxddeconnectiononrequest}
+
+\func{char*}{OnRequest}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}, \param{int *}{size}, \param{int}{ format}}
+
+Message sent to the server application when the client
+calls \helpref{wxDDEConnection::Request}{wxddeconnectionrequest}. The server
+should respond by returning a character string from {\bf OnRequest},
+or NULL to indicate no data.
+
+\membersection{wxDDEConnection::OnStartAdvise}\label{wxddeconnectiononstartadvise}
+
+\func{bool}{OnStartAdvise}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}}
+
+Message sent to the server application by the client, when the client
+wishes to start an `advise loop' for the given topic and item. The
+server can refuse to participate by returning FALSE.
+
+\membersection{wxDDEConnection::OnStopAdvise}\label{wxddeconnectiononstopadvise}
+
+\func{bool}{OnStopAdvise}{\param{const wxString\& }{topic}, \param{const wxString\& }{item}}
+
+Message sent to the server application by the client, when the client
+wishes to stop an `advise loop' for the given topic and item. The
+server can refuse to stop the advise loop by returning FALSE, although
+this doesn't have much meaning in practice.
+
+\membersection{wxDDEConnection::Poke}\label{wxddeconnectionpoke}
+
+\func{bool}{Poke}{\param{const wxString\& }{item}, \param{char* }{data}, \param{int}{ size = -1}, \param{int}{ format = wxCF\_TEXT}}
+
+Called by the client application to poke data into the server. Can be
+used to transfer arbitrary data to the server. Causes the server
+connection's \helpref{wxDDEConnection::OnPoke}{wxddeconnectiononpoke} member
+to be called. Returns TRUE if successful.
+
+\membersection{wxDDEConnection::Request}\label{wxddeconnectionrequest}
+
+\func{char*}{Request}{\param{const wxString\& }{item}, \param{int *}{size}, \param{int}{ format = wxCF\_TEXT}}
+
+Called by the client application to request data from the server. Causes
+the server connection's \helpref{wxDDEConnection::OnRequest}{wxddeconnectiononrequest} member to be called. Returns a
+character string (actually a pointer to the connection's buffer) if
+successful, NULL otherwise.
+
+\membersection{wxDDEConnection::StartAdvise}\label{wxddeconnectionstartadvise}
+
+\func{bool}{StartAdvise}{\param{const wxString\& }{item}}
+
+Called by the client application to ask if an advise loop can be started
+with the server. Causes the server connection's \helpref{wxDDEConnection::OnStartAdvise}{wxddeconnectiononstartadvise}\rtfsp
+member to be called. Returns TRUE if the server okays it, FALSE
+otherwise.
+
+\membersection{wxDDEConnection::StopAdvise}\label{wxddeconnectionstopadvise}
+
+\func{bool}{StopAdvise}{\param{const wxString\& }{item}}
+
+Called by the client application to ask if an advise loop can be
+stopped. Causes the server connection's \helpref{wxDDEConnection::OnStopAdvise}{wxddeconnectiononstopadvise} member
+to be called. Returns TRUE if the server okays it, FALSE otherwise.
+
+

docs/latex/wx/ddeservr.tex

@@ -0,0 +1,45 @@
+\section{\class{wxDDEServer}}\label{wxddeserver}
+
+A wxDDEServer object represents the server part of a client-server DDE
+(Dynamic Data Exchange) conversation (available under both Windows
+and UNIX).
+
+\wxheading{Derived from}
+
+wxDDEObject
+
+\wxheading{See also}
+
+\helpref{IPC overview}{ipcoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDDEServer::wxDDEServer}
+
+\func{}{wxDDEServer}{\void}
+
+Constructs a server object.
+
+\membersection{wxDDEServer::Create}
+
+\func{bool}{Create}{\param{const wxString\& }{service}}
+
+Registers the server using the given service name. Under UNIX, the
+string must contain an integer id which is used as an Internet port
+number. FALSE is returned if the call failed (for example, the port
+number is already in use).
+
+\membersection{wxDDEServer::OnAcceptConnection}\label{wxddeserveronacceptconnection}
+
+\func{wxDDEConnection *}{OnAcceptConnection}{\param{const wxString\& }{topic}}
+
+When a client calls {\bf MakeConnection}, the server receives the
+message and this member is called. The application should derive a
+member to intercept this message and return a connection object of
+either the standard wxDDEConnection type, or of a user-derived type. If the
+topic is ``STDIO'', the application may wish to refuse the connection.
+Under UNIX, when a server is created the OnAcceptConnection message is
+always sent for standard input and output, but in the context of DDE
+messages it doesn't make a lot of sense.
+
+

docs/latex/wx/debugcxt.tex

@@ -0,0 +1,267 @@
+\section{\class{wxDebugContext}}\label{wxdebugcontext}
+
+A class for performing various debugging and memory tracing
+operations. Full functionality (such as printing out objects
+currently allocated) is only present in a debugging build of wxWindows,
+i.e. if the DEBUG symbol is defined and non-zero. wxDebugContext
+and related functions and macros can be compiled out by setting
+USE\_DEBUG\_CONTEXT to 0 is wx\_setup.h
+
+\wxheading{Derived from}
+
+No parent class.
+
+\wxheading{See also}
+
+\overview{Overview}{wxdebugcontextoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDebugContext::Check}\label{wxdebugcontextcheck}
+
+\func{int}{Check}{\void}
+
+Checks the memory blocks for errors, starting from the currently set
+checkpoint.
+
+\wxheading{Return value}
+
+Returns the number of errors,
+so a value of zero represents success. Returns -1 if an error
+was detected that prevents further checking.
+
+\membersection{wxDebugContext::Dump}\label{wxdebugcontextdump}
+
+\func{bool}{Dump}{\void}
+
+Performs a memory dump from the currently set checkpoint, writing to the
+current debug stream. Calls the {\bf Dump} member function for each wxObject
+derived instance.
+
+\wxheading{Return value}
+
+TRUE if the function succeeded, FALSE otherwise.
+
+\membersection{wxDebugContext::GetCheckPrevious}\label{wxdebugcontextgetcheckprevious}
+
+\func{bool}{GetCheckPrevious}{\void}
+
+Returns TRUE if the memory allocator checks all previous memory blocks for errors.
+By default, this is FALSE since it slows down execution considerably.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::SetCheckPrevious}{wxdebugcontextsetcheckprevious}
+
+\membersection{wxDebugContext::GetDebugMode}\label{wxdebugcontextgetdebugmode}
+
+\func{bool}{GetDebugMode}{\void}
+
+Returns TRUE if debug mode is on. If debug mode is on, the wxObject new and delete
+operators store or use information about memory allocation. Otherwise,
+a straight malloc and free will be performed by these operators.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::SetDebugMode}{wxdebugcontextsetdebugmode}
+
+\membersection{wxDebugContext::GetLevel}\label{wxdebugcontextgetlevel}
+
+\func{int}{GetLevel}{\void}
+
+Gets the debug level (default 1). The debug level is used by the wxTraceLevel function and
+the WXTRACELEVEL macro to specify how detailed the trace information is; setting
+a different level will only have an effect if trace statements in the application
+specify a value other than one.
+
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::SetLevel}{wxdebugcontextsetlevel}
+
+\membersection{wxDebugContext::GetStream}\label{wxdebugcontextgetstream}
+
+\func{ostream\&}{GetStream}{\void}
+
+Returns the output stream associated with the debug context.
+
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::SetStream}{wxdebugcontextsetstream}
+
+\membersection{wxDebugContext::GetStreamBuf}\label{wxdebugcontextgetstreambuf}
+
+\func{streambuf*}{GetStreamBuf}{\void}
+
+Returns a pointer to the output stream buffer associated with the debug context.
+There may not necessarily be a stream buffer if the stream has been set
+by the user.
+
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\membersection{wxDebugContext::HasStream}\label{wxdebugcontexthasstream}
+
+\func{bool}{HasStream}{\void}
+
+Returns TRUE if there is a stream currently associated
+with the debug context.
+
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::SetStream}{wxdebugcontextsetstream}, \helpref{wxDebugContext::GetStream}{wxdebugcontextgetstream}
+
+\membersection{wxDebugContext::PrintClasses}\label{wxdebugcontextprintclasses}
+
+\func{bool}{PrintClasses}{\void}
+
+Prints a list of the classes declared in this application, giving derivation
+and whether instances of this class can be dynamically created.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::PrintStatistics}{wxdebugcontextprintstatistics}
+
+\membersection{wxDebugContext::PrintStatistics}\label{wxdebugcontextprintstatistics}
+
+\func{bool}{PrintStatistics}{\param{bool}{ detailed = TRUE}}
+
+Performs a statistics analysis from the currently set checkpoint, writing
+to the current debug stream. The number of object and non-object
+allocations is printed, together with the total size.
+
+\wxheading{Parameters}
+
+\docparam{detailed}{If TRUE, the function will also print how many
+objects of each class have been allocated, and the space taken by
+these class instances.}
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::PrintStatistics}{wxdebugcontextprintstatistics}
+
+\membersection{wxDebugContext::SetCheckpoint}\label{wxdebugcontextsetcheckpoint}
+
+\func{void}{SetCheckpoint}{\param{bool}{ all = FALSE}}
+
+Sets the current checkpoint: Dump and PrintStatistics operations will
+be performed from this point on. This allows you to ignore allocations
+that have been performed up to this point.
+
+\wxheading{Parameters}
+
+\docparam{all}{If TRUE, the checkpoint is reset to include all
+memory allocations since the program started.}
+
+\membersection{wxDebugContext::SetCheckPrevious}\label{wxdebugcontextsetcheckprevious}
+
+\func{void}{SetCheckPrevious}{\param{bool}{ check}}
+
+Tells the memory allocator to check all previous memory blocks for errors.
+By default, this is FALSE since it slows down execution considerably.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::GetCheckPrevious}{wxdebugcontextgetcheckprevious}
+
+\membersection{wxDebugContext::SetDebugMode}\label{wxdebugcontextsetdebugmode}
+
+\func{void}{SetDebugMode}{\param{bool}{ debug}}
+
+Sets the debug mode on or off. If debug mode is on, the wxObject new and delete
+operators store or use information about memory allocation. Otherwise,
+a straight malloc and free will be performed by these operators.
+
+By default, debug mode is on if DEBUG is non-zero. If the application
+uses this function, it should make sure that all object memory allocated
+is deallocated with the same value of debug mode. Otherwise, the
+delete operator might try to look for memory information that does not
+exist.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::GetDebugMode}{wxdebugcontextgetdebugmode}
+
+\membersection{wxDebugContext::SetFile}\label{wxdebugcontextsetfile}
+
+\func{bool}{SetFile}{\param{const wxString\& }{filename}}
+
+Sets the current debug file and creates a stream. This will delete any existing
+stream and stream buffer. By default, the debug context stream
+outputs to the debugger (Windows) or standard error (other platforms).
+
+\membersection{wxDebugContext::SetLevel}\label{wxdebugcontextsetlevel}
+
+\func{void}{SetLevel}{\param{int}{ level}}
+
+Sets the debug level (default 1). The debug level is used by the wxTraceLevel function and
+the WXTRACELEVEL macro to specify how detailed the trace information is; setting
+a different level will only have an effect if trace statements in the application
+specify a value other than one.
+
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::GetLevel}{wxdebugcontextgetlevel}
+
+\membersection{wxDebugContext::SetStandardError}\label{wxdebugcontextsetstandarderror}
+
+\func{bool}{SetStandardError}{\void}
+
+Sets the debugging stream to be the debugger (Windows) or standard error (other platforms).
+This is the default setting. The existing stream will be flushed and deleted.
+
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\membersection{wxDebugContext::SetStream}\label{wxdebugcontextsetstream}
+
+\func{void}{SetStream}{\param{ostream* }{stream}, \param{streambuf* }{streamBuf = NULL}}
+
+Sets the stream and optionally, stream buffer associated with the debug context.
+This operation flushes and deletes the existing stream (and stream buffer if any).
+
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\wxheading{Parameters}
+
+\docparam{stream}{Stream to associate with the debug context. Do not set this to NULL.}
+
+\docparam{streamBuf}{Stream buffer to associate with the debug context.}
+
+\wxheading{See also}
+
+\helpref{wxDebugContext::GetStream}{wxdebugcontextgetstream}, \helpref{wxDebugContext::HasStream}{wxdebugcontexthasstream}
+
+\section{\class{wxDebugStreamBuf}}\label{wxdebugstreambuf}
+
+This class allows you to treat debugging output in a similar
+(stream-based) fashion on different platforms. Under
+Windows, an ostream constructed with this buffer outputs
+to the debugger, or other program that intercepts debugging
+output. On other platforms, the output goes to standard error (cerr).
+
+This is soon to be obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
+\wxheading{Derived from}
+
+streambuf
+
+\wxheading{Example}
+
+\begin{verbatim}
+  wxDebugStreamBuf streamBuf;
+  ostream stream(&streamBuf);
+
+  stream << "Hello world!" << endl;
+\end{verbatim}
+
+\wxheading{See also}
+
+\overview{Overview}{wxdebugcontextoverview}
+
+

docs/latex/wx/dialog.tex

@@ -0,0 +1,311 @@
+\section{\class{wxDialog}}\label{wxdialog}
+
+A dialog box is a window with a title bar and sometimes a system menu, which can be moved around
+the screen. It can contain controls and other windows.
+
+\wxheading{Derived from}
+
+\helpref{wxPanel}{wxpanel}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Remarks}
+
+There are two kinds of dialog - {\it modal} and {\it modeless}. A modal dialog
+blocks program flow and user input on other windows until it is dismissed, whereas a modeless dialog behaves more
+like a frame in that program flow continues, and input on other windows is still possible.
+You specify the type of dialog with the {\bf wxDIALOG\_MODAL} and {\bf wxDIALOG\_MODELESS} window
+styles.
+
+A dialog may be loaded from a wxWindows resource file (extension {\tt wxr}).
+
+An application can define an \helpref{OnCloseWindow}{wxwindowonclosewindow} handler for the
+dialog to respond to system close events.
+
+\wxheading{Window styles}
+
+\twocolwidtha{5cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxCAPTION}}{Puts a caption on the dialog box (Motif only).}
+\twocolitem{\windowstyle{wxDEFAULT\_DIALOG\_STYLE}}{Equivalent to a combination of wxCAPTION, wxSYSTEM\_MENU and wxTHICK\_FRAME}
+\twocolitem{\windowstyle{wxRESIZE\_BORDER}}{Display a resizeable frame around the window (Motif only).}
+\twocolitem{\windowstyle{wxSYSTEM\_MENU}}{Display a system menu.}
+\twocolitem{\windowstyle{wxTHICK\_FRAME}}{Display a thick frame around the window.}
+\twocolitem{\windowstyle{wxSTAY\_ON\_TOP}}{The dialog stays on top of all other windows (Windows only).}
+\twocolitem{\windowstyle{wxNO\_3D}}{Under Windows, specifies that the child controls
+should not have 3D borders unless specified in the control.}
+\end{twocollist}
+
+Under Motif, MWM (the Motif Window Manager) should be running for any of these styles to have an effect.
+
+See also \helpref{Generic window styles}{windowstyles}.
+
+\wxheading{See also}
+
+\helpref{wxDialog overview}{wxdialogoverview}, \helpref{wxFrame}{wxframe}, \helpref{Resources}{resources},\rtfsp
+\helpref{Validator overview}{validatoroverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDialog::wxDialog}\label{wxdialogconstr}
+
+\func{}{wxDialog}{\void}
+
+Default constructor.
+
+\func{}{wxDialog}{\param{wxWindow* }{parent}, \param{wxWindowID }{id},\rtfsp
+\param{const wxString\& }{title},\rtfsp
+\param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
+\param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = wxDEFAULT\_DIALOG\_STYLE},\rtfsp
+\param{const wxString\& }{name = ``dialogBox"}}
+
+Constructor.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Can be NULL, a frame or another dialog box.}
+
+\docparam{id}{An identifier for the dialog. A value of -1 is taken to mean a default.}
+
+\docparam{title}{The title of the dialog.}
+
+\docparam{pos}{The dialog position. A value of (-1, -1) indicates a default position, chosen by
+either the windowing system or wxWindows, depending on platform.}
+
+\docparam{size}{The dialog size. A value of (-1, -1) indicates a default size, chosen by
+either the windowing system or wxWindows, depending on platform.}
+
+\docparam{style}{The window style. See \helpref{wxDialog}{wxdialog}.}
+
+\docparam{name}{Used to associate a name with the window,
+allowing the application user to set Motif resource values for
+individual dialog boxes.}
+
+\wxheading{See also}
+
+\helpref{wxDialog::Create}{wxdialogcreate}
+
+\membersection{wxDialog::\destruct{wxDialog}}
+
+\func{}{\destruct{wxDialog}}{\void}
+
+Destructor. Deletes any child windows before deleting the physical window.
+
+\membersection{wxDialog::Centre}\label{wxdialogcentre}
+
+\func{void}{Centre}{\param{int}{ direction = wxBOTH}}
+
+Centres the dialog box on the display.
+
+\wxheading{Parameters}
+
+\docparam{direction}{May be {\tt wxHORIZONTAL}, {\tt wxVERTICAL} or {\tt wxBOTH}.}
+
+\membersection{wxDialog::Create}\label{wxdialogcreate}
+
+\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID }{id},\rtfsp
+\param{const wxString\& }{title},\rtfsp
+\param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
+\param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = wxDEFAULT\_DIALOG\_STYLE},\rtfsp
+\param{const wxString\& }{name = ``dialogBox"}}
+
+Used for two-step dialog box construction. See \helpref{wxDialog::wxDialog}{wxdialogconstr}\rtfsp
+for details.
+
+\membersection{wxDialog::EndModal}\label{wxdialogendmodal}
+
+\func{void}{EndModal}{\param{int }{retCode}}
+
+Ends a modal dialog, passing a value to be returned from the \helpref{wxDialog::ShowModal}{wxdialogshowmodal}\rtfsp
+invocation.
+
+\wxheading{Parameters}
+
+\docparam{retCode}{The value that should be returned by {\bf ShowModal}.}
+
+\wxheading{See also}
+
+\helpref{wxDialog::ShowModal}{wxdialogshowmodal},\rtfsp
+\helpref{wxWindow::GetReturnCode}{wxwindowgetreturncode},\rtfsp
+\helpref{wxWindow::SetReturnCode}{wxwindowsetreturncode}
+
+\membersection{wxDialog::GetTitle}\label{wxdialoggettitle}
+
+\constfunc{wxString}{GetTitle}{\void}
+
+Returns the title of the dialog box.
+
+\membersection{wxDialog::Iconize}\label{wxdialogiconized}
+
+\func{void}{Iconize}{\param{const bool}{ iconize}}
+
+Iconizes or restores the dialog.
+
+\wxheading{Parameters}
+
+\docparam{iconize}{If TRUE, iconizes the dialog box; if FALSE, shows and restores it.}
+
+\wxheading{Remarks}
+
+Note that in Windows, iconization has no effect since dialog boxes cannot be
+iconized. However, applications may need to explicitly restore dialog
+boxes under Motif which have user-iconizable frames, and under Windows
+calling {\tt Iconize(FALSE)} will bring the window to the front, as does
+\rtfsp{\tt Show(TRUE)}.
+
+\membersection{wxDialog::IsIconized}\label{wxdialogisiconized}
+
+\constfunc{bool}{IsIconized}{\void}
+
+Returns TRUE if the dialog box is iconized.
+
+\wxheading{Remarks}
+
+Always returns FALSE under Windows since dialogs cannot be iconized.
+
+\membersection{wxDialog::IsModal}\label{wxdialogismodal}
+
+\constfunc{bool}{IsModal}{\void}
+
+Returns TRUE if the dialog box is modal, FALSE otherwise.
+
+\membersection{wxDialog::OnCharHook}\label{wxdialogoncharhook}
+
+\func{void}{OnCharHook}{\param{wxKeyEvent\&}{ event}}
+
+This member is called to allow the window to intercept keyboard events
+before they are processed by child windows.
+
+For more information, see \helpref{wxWindow::OnCharHook}{wxwindowoncharhook}
+
+\wxheading{Remarks}
+
+wxDialog implements this handler to fake a cancel command if the escape key has been
+pressed. This will dismiss the dialog.
+
+\membersection{wxDialog::OnApply}\label{wxdialogonapply}
+
+\func{void}{OnApply}{\param{wxCommandEvent\& }{event}}
+
+The default handler for the wxID\_APPLY identifier.
+
+\wxheading{Remarks}
+
+This function calls \helpref{wxWindow::Validate}{wxwindowvalidate} and \helpref{wxWindow::TransferDataToWindow}{wxwindowtransferdatatowindow}.
+
+\wxheading{See also}
+
+\helpref{wxDialog::OnOK}{wxdialogonok}, \helpref{wxDialog::OnCancel}{wxdialogoncancel}
+
+\membersection{wxDialog::OnCancel}\label{wxdialogoncancel}
+
+\func{void}{OnCancel}{\param{wxCommandEvent\& }{event}}
+
+The default handler for the wxID\_CANCEL identifier.
+
+\wxheading{Remarks}
+
+The function either calls {\bf EndModal(wxID\_CANCEL)} if the dialog is modal, or
+sets the return value to wxID\_CANCEL and calls {\bf Show(FALSE)} if the dialog is modeless.
+
+\wxheading{See also}
+
+\helpref{wxDialog::OnOK}{wxdialogonok}, \helpref{wxDialog::OnApply}{wxdialogonapply}
+
+\membersection{wxDialog::OnOK}\label{wxdialogonok}
+
+\func{void}{OnOK}{\param{wxCommandEvent\& }{event}}
+
+The default handler for the wxID\_OK identifier.
+
+\wxheading{Remarks}
+
+The function calls
+\rtfsp\helpref{wxWindow::Validate}{wxwindowvalidate}, then \helpref{wxWindow::TransferDataFromWindow}{wxwindowtransferdatafromwindow}.
+If this returns TRUE, the function either calls {\bf EndModal(wxID\_OK)} if the dialog is modal, or
+sets the return value to wxID\_OK and calls {\bf Show(FALSE)} if the dialog is modeless.
+
+\wxheading{See also}
+
+\helpref{wxDialog::OnCancel}{wxdialogoncancel}, \helpref{wxDialog::OnApply}{wxdialogonapply}
+
+\membersection{wxDialog::OnSysColourChanged}\label{wxdialogonsyscolourchanged}
+
+\func{void}{OnSysColourChanged}{\param{wxSysColourChangedEvent\& }{event}}
+
+The default handler for wxEVT\_SYS\_COLOUR\_CHANGED.
+
+\wxheading{Parameters}
+
+\docparam{event}{The colour change event.}
+
+\wxheading{Remarks}
+
+Changes the dialog's colour to conform to the current settings (Windows only).
+Add an event table entry for your dialog class if you wish the behaviour
+to be different (such as keeping a user-defined
+background colour). If you do override this function, call \helpref{wxWindow::OnSysColourChanged}{wxwindowonsyscolourchanged} to
+propagate the notification to child windows and controls.
+
+\wxheading{See also}
+
+\helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}
+
+\membersection{wxDialog::SetModal}\label{wxdialogsetmodal}
+
+\func{void}{SetModal}{\param{const bool}{ flag}}
+
+Allows the programmer to specify whether the dialog box is modal (wxDialog::Show blocks control
+until the dialog is hidden) or modeless (control returns immediately).
+
+\wxheading{Parameters}
+
+\docparam{flag}{If TRUE, the dialog will be modal, otherwise it will be modeless.}
+
+\membersection{wxDialog::SetTitle}\label{wxdialogsettitle}
+
+\func{void}{SetTitle}{\param{const wxString\& }{ title}}
+
+Sets the title of the dialog box.
+
+\wxheading{Parameters}
+
+\docparam{title}{The dialog box title.}
+
+\membersection{wxDialog::Show}\label{wxdialogshow}
+
+\func{bool}{Show}{\param{const bool}{ show}}
+
+Hides or shows the dialog.
+
+\wxheading{Parameters}
+
+\docparam{show}{If TRUE, the dialog box is shown and brought to the front;
+otherwise the box is hidden. If FALSE and the dialog is
+modal, control is returned to the calling program.}
+
+\wxheading{Remarks}
+
+The preferred way of dismissing a modal dialog is to use \helpref{wxDialog::EndModal}{wxdialogendmodal}.
+
+\membersection{wxDialog::ShowModal}\label{wxdialogshowmodal}
+
+\func{int}{ShowModal}{\void}
+
+Shows a modal dialog. Program flow does not return until the dialog has been dismissed with\rtfsp
+\helpref{wxDialog::EndModal}{wxdialogendmodal}.
+
+\wxheading{Return value}
+
+The return value is the value set with \helpref{wxWindow::SetReturnCode}{wxwindowsetreturncode}.
+
+\wxheading{See also}
+
+\helpref{wxDialog::EndModal}{wxdialogendmodal},\rtfsp
+\helpref{wxWindow::GetReturnCode}{wxwindowgetreturncode},\rtfsp
+\helpref{wxWindow::SetReturnCode}{wxwindowsetreturncode}
+
+

docs/latex/wx/dirdlg.tex

@@ -0,0 +1,86 @@
+\section{\class{wxDirDialog}}\label{wxdirdialog}
+
+This class represents the directory chooser dialog.
+
+\wxheading{Derived from}
+
+\helpref{wxDialog}{wxdialog}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxDirDialog overview}{wxdirdialogoverview}, \helpref{wxFileDialog}{wxfiledialog}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDirDialog::wxDirDialog}\label{wxdirdialogconstr}
+
+\func{}{wxDirDialog}{\param{wxWindow* }{parent}, \param{const wxString\& }{message = "Choose a directory"},\rtfsp
+\param{const wxString\& }{defaultPath = ""}, \param{long }{style = 0}, \param{const wxPoint\& }{pos = wxDefaultPosition}}
+
+Constructor. Use \helpref{wxDirDialog::ShowModal}{wxdirdialogshowmodal} to show the dialog.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window.}
+
+\docparam{message}{Message to show on the dialog.}
+
+\docparam{defaultPath}{The default path, or the empty string.}
+
+\docparam{style}{A dialog style, currently unused.}
+
+\docparam{pos}{Dialog position. Not implemented.}
+
+\membersection{wxDirDialog::\destruct{wxDirDialog}}
+
+\func{}{\destruct{wxDirDialog}}{\void}
+
+Destructor.
+
+\membersection{wxDirDialog::GetPath}\label{wxdirdialoggetpath}
+
+\constfunc{wxString}{GetPath}{\void}
+
+Returns the default or user-selected path.
+
+\membersection{wxDirDialog::GetMessage}\label{wxdirdialoggetmessage}
+
+\constfunc{wxString}{GetMessage}{\void}
+
+Returns the message that will be displayed on the dialog.
+
+\membersection{wxDirDialog::GetStyle}\label{wxdirdialoggetstyle}
+
+\constfunc{long}{GetStyle}{\void}
+
+Returns the dialog style.
+
+\membersection{wxDirDialog::SetMessage}\label{wxdirdialogsetmessage}
+
+\func{void}{SetMessage}{\param{const wxString\& }{message}}
+
+Sets the message that will be displayed on the dialog.
+
+\membersection{wxDirDialog::SetPath}\label{wxdirdialogsetpath}
+
+\func{void}{SetPath}{\param{const wxString\& }{path}}
+
+Sets the default path.
+
+\membersection{wxDirDialog::SetStyle}\label{wxdirdialogsetstyle}
+
+\func{void}{SetStyle}{\param{long }{style}}
+
+Sets the dialog style. This is currently unused.
+
+\membersection{wxDirDialog::ShowModal}\label{wxdirdialogshowmodal}
+
+\func{int}{ShowModal}{\void}
+
+Shows the dialog, returning wxID\_OK if the user pressed OK, and wxOK\_CANCEL
+otherwise.
+
+

docs/latex/wx/docchfrm.tex

@@ -0,0 +1,88 @@
+\section{\class{wxDocChildFrame}}\label{wxdocchildframe}
+
+The wxDocChildFrame class provides a default frame for displaying documents
+on separate windows. This class can only be used for SDI (not MDI) child frames.
+
+The class is part of the document/view framework supported by wxWindows,
+and cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocument}{wxdocument},
+\rtfsp\helpref{wxDocManager}{wxdocmanager} and \helpref{wxDocTemplate}{wxdoctemplate} classes.
+
+See the example application in {\tt samples/docview}.
+
+\wxheading{Derived from}
+
+\helpref{wxFrame}{wxframe}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Document/view overview}{docviewoverview}, \helpref{wxFrame}{wxframe}
+
+\membersection{wxDocChildFrame::m\_childDocument}
+
+\member{wxDocument*}{m\_childDocument}
+
+The document associated with the frame.
+
+\membersection{wxDocChildFrame::m\_childView}
+
+\member{wxView*}{m\_childView}
+
+The view associated with the frame.
+
+\membersection{wxDocChildFrame::wxDocChildFrame}
+
+\func{}{wxDocChildFrame}{\param{wxDocument* }{doc}, \param{wxView* }{view}, \param{wxFrame* }{parent},
+ \param{wxWindowID}{ id}, \param{const wxString\& }{title}, \param{const wxPoint\&}{ pos = wxDefaultPosition},
+ \param{const wxSize\&}{ size = wxDefaultSize},
+ \param{long}{ style = wxDEFAULT\_FRAME\_STYLE}, \param{const wxString\& }{name = ``frame"}}
+
+Constructor.
+
+\membersection{wxDocChildFrame::\destruct{wxDocChildFrame}}
+
+\func{}{\destruct{wxDocChildFrame}}{\void}
+
+Destructor.
+
+\membersection{wxDocChildFrame::GetDocument}
+
+\constfunc{wxDocument*}{GetDocument}{\void}
+
+Returns the document associated with this frame.
+
+\membersection{wxDocChildFrame::GetView}
+
+\constfunc{wxView*}{GetView}{\void}
+
+Returns the view associated with this frame.
+
+\membersection{wxDocChildFrame::OnActivate}
+
+\func{void}{OnActivate}{\param{bool}{ active}}
+
+Sets the currently active view to be the frame's view. You may need
+to override (but still call) this function in order to set the keyboard
+focus for your subwindow.
+
+\membersection{wxDocChildFrame::OnClose}
+
+\func{virtual bool}{OnClose}{\void}
+
+Closes and deletes the current view and document.
+
+\membersection{wxDocChildFrame::SetDocument}
+
+\func{void}{SetDocument}{\param{wxDocument *}{doc}}
+
+Sets the document for this frame.
+
+\membersection{wxDocChildFrame::SetView}
+
+\func{void}{SetView}{\param{wxView *}{view}}
+
+Sets the view for this frame.
+
+

docs/latex/wx/docmanag.tex

@@ -0,0 +1,361 @@
+\section{\class{wxDocManager}}\label{wxdocmanager}
+
+The wxDocManager class is part of the document/view framework supported by wxWindows,
+and cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocument}{wxdocument}\rtfsp
+and \helpref{wxDocTemplate}{wxdoctemplate} classes.
+
+\wxheading{Derived from}
+
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxDocManager overview}{wxdocmanageroverview}, \helpref{wxDocument}{wxdocument},\rtfsp
+\helpref{wxView}{wxview}, \helpref{wxDocTemplate}{wxdoctemplate}, \helpref{wxFileHistory}{wxfilehistory}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDocManager::m\_currentView}
+
+\member{wxView*}{m\_currentView}
+
+The currently active view.
+
+\membersection{wxDocManager::m\_defaultDocumentNameCounter}
+
+\member{int}{m\_defaultDocumentNameCounter}
+
+Stores the integer to be used for the next default document name.
+
+\membersection{wxDocManager::m\_fileHistory}
+
+\member{wxFileHistory*}{m\_fileHistory}
+
+A pointer to an instance of \helpref{wxFileHistory}{wxfilehistory},
+which manages the history of recently-visited files on the File menu.
+
+\membersection{wxDocManager::m\_maxDocsOpen}
+
+\member{int}{m\_maxDocsOpen}
+
+Stores the maximum number of documents that can be opened before
+existing documents are closed. By default, this is 10,000.
+
+\membersection{wxDocManager::m\_docs}
+
+\member{wxList}{m\_docs}
+
+A list of all documents.
+
+\membersection{wxDocManager::m\_flags}
+
+\member{long}{m\_flags}
+
+Stores the flags passed to the constructor.
+
+\membersection{wxDocManager::m\_templates}
+
+\member{wxList}{mnTemplates}
+
+A list of all document templates.
+
+\membersection{wxDocManager::wxDocManager}
+
+\func{void}{wxDocManager}{\param{long}{ flags = wxDEFAULT\_DOCMAN\_FLAGS}, \param{bool}{ initialize = TRUE}}
+
+Constructor. Create a document manager instance dynamically near the start of your application
+before doing any document or view operations.
+
+{\it flags} is currently unused.
+
+If {\it initialize} is TRUE, the \helpref{Initialize}{wxdocmanagerinitialize} function will be called
+to create a default history list object. If you derive from wxDocManager, you may wish to call the
+base constructor with FALSE, and then call Initialize in your own constructor, to allow
+your own Initialize or OnCreateFileHistory functions to be called.
+
+\membersection{wxDocManager::\destruct{wxDocManager}}
+
+\func{void}{\destruct{wxDocManager}}{\void}
+
+Destructor.
+
+\membersection{wxDocManager::ActivateView}
+
+\func{void}{ActivateView}{\param{wxView* }{doc}, \param{bool}{ activate}, \param{bool}{ deleting}}
+
+Sets the current view.
+
+\membersection{wxDocManager::AddDocument}
+
+\func{void}{AddDocument}{\param{wxDocument *}{doc}}
+
+Adds the document to the list of documents.
+
+\membersection{wxDocManager::AddFileToHistory}
+
+\func{void}{AddFileToHistory}{\param{const wxString\& }{filename}}
+
+Adds a file to the file history list, if we have a pointer to an appropriate file menu.
+
+\membersection{wxDocManager::AssociateTemplate}
+
+\func{void}{AssociateTemplate}{\param{wxDocTemplate *}{temp}}
+
+Adds the template to the document manager's template list.
+
+\membersection{wxDocManager::CreateDocument}
+
+\func{wxDocument*}{CreateDocument}{\param{const wxString\& }{path}, \param{long}{ flags}}
+
+Creates a new document in a manner determined by the {\it flags} parameter, which can be:
+
+\begin{itemize}\itemsep=0pt
+\item wxDOC\_NEW Creates a fresh document.
+\item wxDOC\_SILENT Silently loads the given document file.
+\end{itemize}
+
+If wxDOC\_NEW is present, a new document will be created and returned, possibly after
+asking the user for a template to use if there is more than one document template.
+If wxDOC\_SILENT is present, a new document will be created and the given file loaded
+into it. If neither of these flags is present, the user will be presented with
+a file selector for the file to load, and the template to use will be determined by the
+extension (Windows) or by popping up a template choice list (other platforms).
+
+If the maximum number of documents has been reached, this function
+will delete the oldest currently loaded document before creating a new one.
+
+\membersection{wxDocManager::CreateView}
+
+\func{wxView*}{CreateView}{\param{wxDocument*}{doc}, \param{long}{ flags}}
+
+Creates a new view for the given document. If more than one view is allowed for the
+document (by virtue of multiple templates mentioning the same document type), a choice
+of view is presented to the user.
+
+\membersection{wxDocManager::DisassociateTemplate}
+
+\func{void}{DisassociateTemplate}{\param{wxDocTemplate *}{temp}}
+
+Removes the template from the list of templates.
+
+\membersection{wxDocManager::FileHistoryAddFilesToMenu}\label{wxdocmanagerfilehistoryaddfilestomenu}
+
+\func{void}{FileHistoryAddFilesToMenu}{\void}
+
+Appends the files in the history list, to all menus managed by the file history object.
+
+\func{void}{FileHistoryAddFilesToMenu}{\param{wxMenu*}{ menu}}
+
+Appends the files in the history list, to the given menu only.
+
+\membersection{wxDocManager::FileHistoryLoad}\label{wxdocmanagerfilehistoryload}
+
+\func{void}{FileHistoryLoad}{\param{wxConfigBase\& }{config}}
+
+Loads the file history from a config object.
+
+\wxheading{See also}
+
+\helpref{wxConfig}{wxconfigbase}
+
+\membersection{wxDocManager::FileHistoryRemoveMenu}\label{wxdocmanagerfilehistoryremovemenu}
+
+\func{void}{FileHistoryRemoveMenu}{\param{wxMenu*}{ menu}}
+
+Removes the given menu from the list of menus managed by the file history object.
+
+\membersection{wxDocManager::FileHistorySave}\label{wxdocmanagerfilehistorysave}
+
+\func{void}{FileHistorySave}{\param{wxConfigBase\& }{resourceFile}}
+
+Saves the file history into a config object. This must be called
+explicitly by the application.
+
+\wxheading{See also}
+
+\helpref{wxConfig}{wxconfigbase}
+
+\membersection{wxDocManager::FileHistoryUseMenu}\label{wxdocmanagerfilehistoryusemenu}
+
+\func{void}{FileHistoryUseMenu}{\param{wxMenu*}{ menu}}
+
+Use this menu for appending recently-visited document filenames, for convenient
+access. Calling this function with a valid menu pointer enables the history
+list functionality.
+
+Note that you can add multiple menus using this function, to be managed by the
+file history object.
+
+\membersection{wxDocManager::FindTemplateForPath}
+
+\func{wxDocTemplate *}{FindTemplateForPath}{\param{const wxString\& }{path}}
+
+Given a path, try to find template that matches the extension. This is only
+an approximate method of finding a template for creating a document.
+
+\membersection{wxDocManager::GetCurrentDocument}
+
+\func{wxDocument *}{GetCurrentDocument}{\void}
+
+Returns the document associated with the currently active view (if any).
+
+\membersection{wxDocManager::GetCurrentView}
+
+\func{wxView *}{GetCurrentView}{\void}
+
+Returns the currently active view 
+
+\membersection{wxDocManager::GetDocuments}
+
+\func{wxList\&}{GetDocuments}{\void}
+
+Returns a reference to the list of documents.
+
+\membersection{wxDocManager::GetFileHistory}
+
+\func{wxFileHistory *}{GetFileHistory}{\void}
+
+Returns a pointer to file history.
+
+\membersection{wxDocManager::GetMaxDocsOpen}
+
+\func{int}{GetMaxDocsOpen}{\void}
+
+Returns the number of documents that can be open simultaneously.
+
+\membersection{wxDocManager::GetNoHistoryFiles}
+
+\func{int}{GetNoHistoryFiles}{\void}
+
+Returns the number of files currently stored in the file history.
+
+\membersection{wxDocManager::Initialize}\label{wxdocmanagerinitialize}
+
+\func{bool}{Initialize}{\void}
+
+Initializes data; currently just calls OnCreateFileHistory. Some data cannot
+always be initialized in the constructor because the programmer must be given
+the opportunity to override functionality. If OnCreateFileHistory was called
+from the constructor, an overridden virtual OnCreateFileHistory would not be
+called due to C++'s `interesting' constructor semantics. In fact Initialize
+\rtfsp{\it is} called from the wxDocManager constructor, but this can be
+vetoed by passing FALSE to the second argument, allowing the derived class's
+constructor to call Initialize, possibly calling a different OnCreateFileHistory
+from the default.
+
+The bottom line: if you're not deriving from Initialize, forget it and
+construct wxDocManager with no arguments.
+
+\membersection{wxDocManager::MakeDefaultName}
+
+\func{bool}{MakeDefaultName}{\param{const wxString\& }{buf}}
+
+Copies a suitable default name into {\it buf}. This is implemented by
+appending an integer counter to the string {\bf unnamed} and incrementing
+the counter.
+
+\membersection{wxDocManager::OnCreateFileHistory}
+
+\func{wxFileHistory *}{OnCreateFileHistory}{\void}
+
+A hook to allow a derived class to create a different type of file history. Called
+from \helpref{Initialize}{wxdocmanagerinitialize}.
+
+\membersection{wxDocManager::OnFileClose}
+
+\func{void}{OnFileClose}{\void}
+
+Closes and deletes the currently active document.
+
+\membersection{wxDocManager::OnFileNew}
+
+\func{void}{OnFileNew}{\void}
+
+Creates a document from a list of templates (if more than one template).
+
+\membersection{wxDocManager::OnFileOpen}
+
+\func{void}{OnFileOpen}{\void}
+
+Creates a new document and reads in the selected file.
+
+\membersection{wxDocManager::OnFileSave}
+
+\func{void}{OnFileSave}{\void}
+
+Saves the current document by calling wxDocument::Save for the current document.
+
+\membersection{wxDocManager::OnFileSaveAs}
+
+\func{void}{OnFileSaveAs}{\void}
+
+Calls wxDocument::SaveAs for the current document.
+
+\membersection{wxDocManager::OnMenuCommand}
+
+\func{void}{OnMenuCommand}{\param{int}{ cmd}}
+
+Processes menu commands routed from child or parent frames. This deals
+with the following predefined menu item identifiers:
+
+\begin{itemize}\itemsep=0pt
+\item wxID\_OPEN Creates a new document and opens a file into it.
+\item wxID\_CLOSE Closes the current document.
+\item wxID\_NEW Creates a new document.
+\item wxID\_SAVE Saves the document.
+\item wxID\_SAVE\_AS Saves the document into a specified filename.
+\end{itemize}
+
+Unrecognized commands are routed to the currently active wxView's OnMenuCommand.
+
+\membersection{wxDocManager::RemoveDocument}
+
+\func{void}{RemoveDocument}{\param{wxDocument *}{doc}}
+
+Removes the document from the list of documents.
+
+\membersection{wxDocManager::SelectDocumentPath}
+
+\func{wxDocTemplate *}{SelectDocumentPath}{\param{wxDocTemplate **}{templates},
+ \param{int}{ noTemplates}, \param{const wxString\& }{path}, \param{const wxString\& }{bufSize},
+ \param{long}{ flags}, \param{bool}{ save}}
+
+Under Windows, pops up a file selector with a list of filters corresponding to document templates.
+The wxDocTemplate corresponding to the selected file's extension is returned.
+
+On other platforms, if there is more than one document template a choice list is popped up,
+followed by a file selector.
+
+This function is used in wxDocManager::CreateDocument.
+
+\membersection{wxDocManager::SelectDocumentType}
+
+\func{wxDocTemplate *}{SelectDocumentType}{\param{wxDocTemplate **}{templates},
+ \param{int}{ noTemplates}}
+
+Returns a document template by asking the user (if there is more than one template).
+This function is used in wxDocManager::CreateDocument.
+
+\membersection{wxDocManager::SelectViewType}
+
+\func{wxDocTemplate *}{SelectViewType}{\param{wxDocTemplate **}{templates},
+ \param{int}{ noTemplates}}
+
+Returns a document template by asking the user (if there is more than one template),
+displaying a list of valid views. This function is used in wxDocManager::CreateView.
+The dialog normally won't appear because the array of templates only contains
+those relevant to the document in question, and often there will only be one such.
+
+\membersection{wxDocManager::SetMaxDocsOpen}
+
+\func{void}{SetMaxDocsOpen}{\param{int}{ n}}
+
+Sets the maximum number of documents that can be open at a time. By default, this
+is 10,000. If you set it to 1, existing documents will be saved and deleted
+when the user tries to open or create a new one (similar to the behaviour
+of Windows Write, for example). Allowing multiple documents gives behaviour
+more akin to MS Word and other Multiple Document Interface applications.
+
+
+

docs/latex/wx/docmdich.tex

@@ -0,0 +1,89 @@
+\section{\class{wxDocMDIChildFrame}}\label{wxdocmdichildframe}
+
+The wxDocMDIChildFrame class provides a default frame for displaying documents
+on separate windows. This class can only be used for MDI child frames.
+
+The class is part of the document/view framework supported by wxWindows,
+and cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocument}{wxdocument},
+\rtfsp\helpref{wxDocManager}{wxdocmanager} and \helpref{wxDocTemplate}{wxdoctemplate} classes.
+
+See the example application in {\tt samples/docview}.
+
+\wxheading{Derived from}
+
+\helpref{wxMDIChildFrame}{wxmdichildframe}\\
+\helpref{wxFrame}{wxframe}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Document/view overview}{docviewoverview}, \helpref{wxMDIChildFrame}{wxmdichildframe}
+
+\membersection{wxDocMDIChildFrame::m\_childDocument}
+
+\member{wxDocument*}{m\_childDocument}
+
+The document associated with the frame.
+
+\membersection{wxDocMDIChildFrame::m\_childView}
+
+\member{wxView*}{m\_childView}
+
+The view associated with the frame.
+
+\membersection{wxDocMDIChildFrame::wxDocMDIChildFrame}
+
+\func{}{wxDocMDIChildFrame}{\param{wxDocument* }{doc}, \param{wxView* }{view}, \param{wxFrame* }{parent},
+ \param{wxWindowID}{ id}, \param{const wxString\& }{title}, \param{const wxPoint\&}{ pos = wxDefaultPosition},
+ \param{const wxSize\&}{ size = wxDefaultSize},
+ \param{long}{ style = wxDEFAULT\_FRAME\_STYLE}, \param{const wxString\& }{name = ``frame"}}
+
+Constructor.
+
+\membersection{wxDocMDIChildFrame::\destruct{wxDocMDIChildFrame}}
+
+\func{}{\destruct{wxDocMDIChildFrame}}{\void}
+
+Destructor.
+
+\membersection{wxDocMDIChildFrame::GetDocument}
+
+\constfunc{wxDocument*}{GetDocument}{\void}
+
+Returns the document associated with this frame.
+
+\membersection{wxDocMDIChildFrame::GetView}
+
+\constfunc{wxView*}{GetView}{\void}
+
+Returns the view associated with this frame.
+
+\membersection{wxDocMDIChildFrame::OnActivate}
+
+\func{void}{OnActivate}{\param{bool}{ active}}
+
+Sets the currently active view to be the frame's view. You may need
+to override (but still call) this function in order to set the keyboard
+focus for your subwindow.
+
+\membersection{wxDocMDIChildFrame::OnClose}
+
+\func{virtual bool}{OnClose}{\void}
+
+Closes and deletes the current view and document.
+
+\membersection{wxDocMDIChildFrame::SetDocument}
+
+\func{void}{SetDocument}{\param{wxDocument *}{doc}}
+
+Sets the document for this frame.
+
+\membersection{wxDocMDIChildFrame::SetView}
+
+\func{void}{SetView}{\param{wxView *}{view}}
+
+Sets the view for this frame.
+
+

docs/latex/wx/docmdipr.tex

@@ -0,0 +1,79 @@
+\section{\class{wxDocMDIParentFrame}}\label{wxdocmdiparentframe}
+
+The wxDocMDIParentFrame class provides a default top-level frame for
+applications using the document/view framework. This class can only be used for MDI parent frames.
+
+It cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocument}{wxdocument},
+\rtfsp\helpref{wxDocManager}{wxdocmanager} and \helpref{wxDocTemplates}{wxdoctemplate} classes.
+
+See the example application in {\tt samples/docview}.
+
+\wxheading{Derived from}
+
+\helpref{wxMDIParentFrame}{wxmdiparentframe}\\
+\helpref{wxFrame}{wxframe}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Document/view overview}{docviewoverview}, \helpref{wxMDIParentFrame}{wxmdiparentframe}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDocMDIParentFrame::wxDocMDIParentFrame}
+
+\func{}{wxDocMDIParentFrame}{\param{wxFrame *}{parent}, \param{wxWindowID}{ id},
+ \param{const wxString\& }{title}, \param{int}{ x}, \param{int}{ y}, \param{int}{ width}, \param{int}{ height},
+ \param{long}{ style}, \param{const wxString\& }{name}}
+
+Constructor.
+
+\membersection{wxDocMDIParentFrame::\destruct{wxDocMDIParentFrame}}
+
+\func{}{\destruct{wxDocMDIParentFrame}}{\void}
+
+Destructor.
+
+\membersection{wxDocMDIParentFrame::OnClose}
+
+\func{bool}{OnClose}{\void}
+
+Deletes all views and documents. If no user input cancelled the
+operation, the function returns TRUE and the application will exit.
+
+Since understanding how document/view clean-up takes place can be difficult,
+the implementation of this function is shown below.
+
+\begin{verbatim}
+bool wxDocMDIParentFrame::OnClose(void)
+{
+  // Delete all views and documents
+  wxNode *node = docManager->GetDocuments().First();
+  while (node)
+  {
+    wxDocument *doc = (wxDocument *)node->Data();
+    wxNode *next = node->Next();
+
+    if (!doc->Close())
+      return FALSE;
+
+    // Implicitly deletes the document when the last
+    // view is removed (deleted)
+    doc->DeleteAllViews();
+
+    // Check document is deleted
+    if (docManager->GetDocuments().Member(doc))
+      delete doc;
+
+    // This assumes that documents are not connected in
+    // any way, i.e. deleting one document does NOT
+    // delete another.
+    node = next;
+  }
+  return TRUE;
+}
+\end{verbatim}
+
+

docs/latex/wx/docprfrm.tex

@@ -0,0 +1,78 @@
+\section{\class{wxDocParentFrame}}\label{wxdocparentframe}
+
+The wxDocParentFrame class provides a default top-level frame for
+applications using the document/view framework. This class can only be used for SDI (not MDI) parent frames.
+
+It cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocument}{wxdocument},
+\rtfsp\helpref{wxDocManager}{wxdocmanager} and \helpref{wxDocTemplates}{wxdoctemplate} classes.
+
+See the example application in {\tt samples/docview}.
+
+\wxheading{Derived from}
+
+\helpref{wxFrame}{wxframe}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Document/view overview}{docviewoverview}, \helpref{wxFrame}{wxframe}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDocParentFrame::wxDocParentFrame}
+
+\func{}{wxDocParentFrame}{\param{wxFrame *}{parent}, \param{wxWindowID}{ id},
+ \param{const wxString\& }{title}, \param{int}{ x}, \param{int}{ y}, \param{int}{ width}, \param{int}{ height},
+ \param{long}{ style}, \param{const wxString\& }{name}}
+
+Constructor.
+
+\membersection{wxDocParentFrame::\destruct{wxDocParentFrame}}
+
+\func{}{\destruct{wxDocParentFrame}}{\void}
+
+Destructor.
+
+\membersection{wxDocParentFrame::OnClose}
+
+\func{bool}{OnClose}{\void}
+
+Deletes all views and documents. If no user input cancelled the
+operation, the function returns TRUE and the application will exit.
+
+Since understanding how document/view clean-up takes place can be difficult,
+the implementation of this function is shown below.
+
+\begin{verbatim}
+bool wxDocParentFrame::OnClose(void)
+{
+  // Delete all views and documents
+  wxNode *node = docManager->GetDocuments().First();
+  while (node)
+  {
+    wxDocument *doc = (wxDocument *)node->Data();
+    wxNode *next = node->Next();
+
+    if (!doc->Close())
+      return FALSE;
+
+    // Implicitly deletes the document when the last
+    // view is removed (deleted)
+    doc->DeleteAllViews();
+
+    // Check document is deleted
+    if (docManager->GetDocuments().Member(doc))
+      delete doc;
+
+    // This assumes that documents are not connected in
+    // any way, i.e. deleting one document does NOT
+    // delete another.
+    node = next;
+  }
+  return TRUE;
+}
+\end{verbatim}
+
+

docs/latex/wx/doctempl.tex

@@ -0,0 +1,233 @@
+\section{\class{wxDocTemplate}}\label{wxdoctemplate}
+
+The wxDocTemplate class is used to model the relationship between a
+document class and a view class.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxDocTemplate overview}{wxdoctemplateoverview}, \helpref{wxDocument}{wxdocument}, \helpref{wxView}{wxview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDocTemplate::m\_defaultExt}
+
+\member{wxString}{m\_defaultExt}
+
+The default extension for files of this type.
+
+\membersection{wxDocTemplate::m\_description}
+
+\member{wxString}{m\_description}
+
+A short description of this template.
+
+\membersection{wxDocTemplate::m\_directory}
+
+\member{wxString}{m\_directory}
+
+The default directory for files of this type.
+
+\membersection{wxDocTemplate::m\_docClassInfo}
+
+\member{wxClassInfo* }{m\_docClassInfo}
+
+Run-time class information that allows document instances to be constructed dynamically.
+
+\membersection{wxDocTemplate::m\_docTypeName}
+
+\member{wxString}{m\_docTypeName}
+
+The named type of the document associated with this template.
+
+\membersection{wxDocTemplate::m\_documentManager}
+
+\member{wxDocTemplate*}{m\_documentManager}
+
+A pointer to the document manager for which this template was created.
+
+\membersection{wxDocTemplate::m\_fileFilter}
+
+\member{wxString}{m\_fileFilter}
+
+The file filter (such as \verb$*.txt$) to be used in file selector dialogs.
+
+\membersection{wxDocTemplate::m\_flags}
+
+\member{long}{m\_flags}
+
+The flags passed to the constructor.
+
+\membersection{wxDocTemplate::m\_viewClassInfo}
+
+\member{wxClassInfo*}{m\_viewClassInfo}
+
+Run-time class information that allows view instances to be constructed dynamically.
+
+\membersection{wxDocTemplate::m\_viewTypeName}
+
+\member{wxString}{m\_viewTypeName}
+
+The named type of the view associated with this template.
+
+\membersection{wxDocTemplate::wxDocTemplate}
+
+\func{}{wxDocTemplate}{\param{wxDocManager* }{manager}, \param{const wxString\& }{descr}, \param{const wxString\& }{filter},
+ \param{const wxString\& }{dir}, \param{const wxString\& }{ext}, \param{const wxString\& }{docTypeName},
+ \param{const wxString\& }{viewTypeName}, \param{wxClassInfo* }{docClassInfo = NULL},
+ \param{wxClassInfo* }{viewClassInfo = NULL}, \param{long}{ flags = wxDEFAULT\_TEMPLATE\_FLAGS}}
+
+Constructor. Create instances dynamically near the start of your application after creating
+a wxDocManager instance, and before doing any document or view operations.
+
+{\it manager} is the document manager object which manages this template.
+
+{\it descr} is a short description of what the template is for. This string will be displayed in the
+file filter list of Windows file selectors.
+
+{\it filter} is an appropriate file filter such as \verb$*.txt$.
+
+{\it dir} is the default directory to use for file selectors.
+
+{\it ext} is the default file extension (such as txt).
+
+{\it docTypeName} is a name that should be unique for a given type of document, used for
+gathering a list of views relevant to a particular document.
+
+{\it viewTypeName} is a name that should be unique for a given view.
+
+{\it docClassInfo} is a pointer to the run-time document class information as returned
+by the CLASSINFO macro, e.g. CLASSINFO(MyDocumentClass). If this is not supplied,
+you will need to derive a new wxDocTemplate class and override the CreateDocument
+member to return a new document instance on demand.
+
+{\it viewClassInfo} is a pointer to the run-time view class information as returned
+by the CLASSINFO macro, e.g. CLASSINFO(MyViewClass). If this is not supplied,
+you will need to derive a new wxDocTemplate class and override the CreateView
+member to return a new view instance on demand.
+
+{\it flags} is a bit list of the following:
+
+\begin{itemize}\itemsep=0pt
+\item wxTEMPLATE\_VISIBLE The template may be displayed to the user in dialogs.
+\item wxTEMPLATE\_INVISIBLE The template may not be displayed to the user in dialogs.
+\item wxDEFAULT\_TEMPLATE\_FLAGS Defined as wxTEMPLATE\_VISIBLE.
+\end{itemize}
+
+\membersection{wxDocTemplate::\destruct{wxDocTemplate}}
+
+\func{void}{\destruct{wxDocTemplate}}{\void}
+
+Destructor.
+
+\membersection{wxDocTemplate::CreateDocument}
+
+\func{wxDocument *}{CreateDocument}{\param{const wxString\& }{path}, \param{long}{ flags = 0}}
+
+Creates a new instance of the associated document class. If you have not supplied
+a wxClassInfo parameter to the template constructor, you will need to override this
+function to return an appropriate document instance.
+
+\membersection{wxDocTemplate::CreateView}
+
+\func{wxView *}{CreateView}{\param{wxDocument *}{doc}, \param{long}{ flags = 0}}
+
+Creates a new instance of the associated view class. If you have not supplied
+a wxClassInfo parameter to the template constructor, you will need to override this
+function to return an appropriate view instance.
+
+\membersection{wxDocTemplate::GetDefaultExtension}
+
+\func{wxString}{GetDefaultExtension}{\void}
+
+Returns the default file extension for the document data, as passed to the document template constructor.
+
+\membersection{wxDocTemplate::GetDescription}
+
+\func{wxString}{GetDescription}{\void}
+
+Returns the text description of this template, as passed to the document template constructor.
+
+\membersection{wxDocTemplate::GetDirectory}
+
+\func{wxString}{GetDirectory}{\void}
+
+Returns the default directory, as passed to the document template constructor.
+
+\membersection{wxDocTemplate::GetDocumentManager}
+
+\func{wxDocManager *}{GetDocumentManager}{\void}
+
+Returns a pointer to the document manager instance for which this template was created.
+
+\membersection{wxDocTemplate::GetDocumentName}
+
+\func{wxString}{GetDocumentName}{\void}
+
+Returns the document type name, as passed to the document template constructor.
+
+\membersection{wxDocTemplate::GetFileFilter}
+
+\func{wxString}{GetFileFilter}{\void}
+
+Returns the file filter, as passed to the document template constructor.
+
+\membersection{wxDocTemplate::GetFlags}
+
+\func{long}{GetFlags}{\void}
+
+Returns the flags, as passed to the document template constructor.
+
+\membersection{wxDocTemplate::GetViewName}
+
+\func{wxString}{GetViewName}{\void}
+
+Returns the view type name, as passed to the document template constructor.
+
+\membersection{wxDocTemplate::IsVisible}
+
+\func{bool}{IsVisible}{\void}
+
+Returns TRUE if the document template can be shown in user dialogs, FALSE otherwise.
+
+\membersection{wxDocTemplate::SetDefaultExtension}
+
+\func{void}{SetDefaultExtension}{\param{const wxString\& }{ext}}
+
+Sets the default file extension.
+
+\membersection{wxDocTemplate::SetDescription}
+
+\func{void}{SetDescription}{\param{const wxString\& }{descr}}
+
+Sets the template description.
+
+\membersection{wxDocTemplate::SetDirectory}
+
+\func{void}{SetDirectory}{\param{const wxString\& }{dir}}
+
+Sets the default directory.
+
+\membersection{wxDocTemplate::SetDocumentManager}
+
+\func{void}{SetDocumentManager}{\param{wxDocManager *}{manager}}
+
+Sets the pointer to the document manager instance for which this template was created.
+Should not be called by the application.
+
+\membersection{wxDocTemplate::SetFileFilter}
+
+\func{void}{SetFileFilter}{\param{const wxString\& }{filter}}
+
+Sets the file filter.
+
+\membersection{wxDocTemplate::SetFlags}
+
+\func{void}{SetFlags}{\param{long }{flags}}
+
+Sets the internal document template flags (see the constructor description for more details).
+
+

docs/latex/wx/document.tex

@@ -0,0 +1,331 @@
+\section{\class{wxDocument}}\label{wxdocument}
+
+The document class can be used to model an application's file-based
+data. It is part of the document/view framework supported by wxWindows,
+and cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocTemplate}{wxdoctemplate}\rtfsp
+and \helpref{wxDocManager}{wxdocmanager} classes.
+
+\wxheading{Derived from}
+
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxDocument overview}{wxdocumentoverview}, \helpref{wxView}{wxview},\rtfsp
+\helpref{wxDocTemplate}{wxdoctemplate}, \helpref{wxDocManager}{wxdocmanager}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDocument::m\_commandProcessor}
+
+\member{wxCommandProcessor*}{m\_commandProcessor}
+
+A pointer to the command processor associated with this document.
+
+\membersection{wxDocument::m\_documentFile}
+
+\member{wxString}{m\_documentFile}
+
+Filename associated with this document (``" if none).
+
+\membersection{wxDocument::m\_documentModified}
+
+\member{bool}{m\_documentModified}
+
+TRUE if the document has been modified, FALSE otherwise.
+
+\membersection{wxDocument::m\_documentTemplate}
+
+\member{wxDocTemplate *}{m\_documentTemplate}
+
+A pointer to the template from which this document was created.
+
+\membersection{wxDocument::m\_documentTitle}
+
+\member{wxString}{m\_documentTitle}
+
+Document title. The document title is used for an associated
+frame (if any), and is usually constructed by the framework from
+the filename.
+
+\membersection{wxDocument::m\_documentTypeName}\label{documenttypename}
+
+\member{wxString}{m\_documentTypeName}
+
+The document type name given to the wxDocTemplate constructor, copied to this
+variable when the document is created. If several document templates are
+created that use the same document type, this variable is used in wxDocManager::CreateView
+to collate a list of alternative view types that can be used on this kind of
+document. Do not change the value of this variable.
+
+\membersection{wxDocument::m\_documentViews}
+
+\member{wxList}{m\_documentViews}
+
+List of wxView instances associated with this document.
+
+\membersection{wxDocument::wxDocument}
+
+\func{}{wxDocument}{\void}
+
+Constructor. Define your own default constructor to initialize application-specific
+data.
+
+\membersection{wxDocument::\destruct{wxDocument}}
+
+\func{}{\destruct{wxDocument}}{\void}
+
+Destructor. Removes itself from the document manager.
+
+\membersection{wxDocument::AddView}
+
+\func{virtual bool}{AddView}{\param{wxView *}{view}}
+
+If the view is not already in the list of views, adds the view and calls OnChangedViewList.
+
+\membersection{wxDocument::Close}
+
+\func{virtual bool}{Close}{\void}
+
+Closes the document, by calling OnSaveModified and then (if this returned TRUE) OnCloseDocument.
+This does not normally delete the document object: use DeleteAllViews to do this implicitly.
+
+\membersection{wxDocument::DeleteAllViews}
+
+\func{virtual bool}{DeleteAllViews}{\void}
+
+Calls wxView::Close and deletes each view. Deleting the final view will implicitly
+delete the document itself, because the wxView destructor calls RemoveView. This
+in turns calls wxDocument::OnChangedViewList, whose default implemention is to
+save and delete the document if no views exist.
+
+\membersection{wxDocument::GetCommandProcessor}
+
+\constfunc{wxCommandProcessor*}{GetCommandProcessor}{\void}
+
+Returns a pointer to the command processor associated with this document.
+
+See \helpref{wxCommandProcessor}{wxcommandprocessor}.
+
+\membersection{wxDocument::GetDocumentTemplate}
+
+\constfunc{wxDocTemplate*}{GetDocumentTemplate}{\void}
+
+Gets a pointer to the template that created the document.
+
+\membersection{wxDocument::GetDocumentManager}
+
+\constfunc{wxDocManager*}{GetDocumentManager}{\void}
+
+Gets a pointer to the associated document manager.
+
+\membersection{wxDocument::GetDocumentName}
+
+\constfunc{wxString}{GetDocumentName}{\void}
+
+Gets the document type name for this document. See the comment for \helpref{documentTypeName}{documenttypename}.
+
+\membersection{wxDocument::GetDocumentWindow}
+
+\constfunc{wxWindow*}{GetDocumentWindow}{\void}
+
+Intended to return a suitable window for using as a parent for document-related
+dialog boxes. By default, uses the frame associated with the first view.
+
+\membersection{wxDocument::GetFilename}
+
+\constfunc{wxString}{GetFilename}{\void}
+
+Gets the filename associated with this document, or NULL if none is
+associated.
+
+\membersection{wxDocument::GetFirstView}
+
+\constfunc{wxView*}{GetFirstView}{\void}
+
+A convenience function to get the first view for a document, because
+in many cases a document will only have a single view.
+
+\membersection{wxDocument::GetPrintableName}
+
+\constfunc{virtual void}{GetPrintableName}{\param{wxString\& }{name}}
+
+Copies a suitable document name into the supplied {\it name} buffer. The default
+function uses the title, or if there is no title, uses the filename; or if no
+filename, the string {\bf unnamed}. 
+
+\membersection{wxDocument::GetTitle}
+
+\constfunc{wxString}{GetTitle}{\void}
+
+Gets the title for this document. The document title is used for an associated
+frame (if any), and is usually constructed by the framework from
+the filename.
+
+\membersection{wxDocument::IsModified}\label{wxdocumentismodified}
+
+\constfunc{virtual bool}{IsModified}{\void}
+
+Returns TRUE if the document has been modified since the last save, FALSE otherwise.
+You may need to override this if your document view maintains its own
+record of being modified (for example if using wxTextWindow to view and edit the document).
+
+See also \helpref{Modify}{wxdocumentmodify}.
+
+\membersection{wxDocument::LoadObject}
+
+\func{virtual istream\&}{LoadObject}{\param{istream\& }{stream}}
+
+Override this function and call it from your own LoadObject before
+streaming your own data. LoadObject is called by the framework
+automatically when the document contents need to be loaded.
+
+\membersection{wxDocument::Modify}\label{wxdocumentmodify}
+
+\func{virtual void}{Modify}{\param{bool}{ modify}}
+
+Call with TRUE to mark the document as modified since the last save, FALSE otherwise.
+You may need to override this if your document view maintains its own
+record of being modified (for example if using wxTextWindow to view and edit the document).
+
+See also \helpref{IsModified}{wxdocumentismodified}.
+
+\membersection{wxDocument::OnChangedViewList}
+
+\func{virtual void}{OnChangedViewList}{\void}
+
+Called when a view is added to or deleted from this document. The default
+implementation saves and deletes the document if no views exist (the last
+one has just been removed).
+
+\membersection{wxDocument::OnCloseDocument}
+
+\func{virtual bool}{OnCloseDocument}{\void}
+
+The default implementation calls DeleteContents (an empty implementation)
+sets the modified flag to FALSE. Override this to
+supply additional behaviour when the document is closed with Close.
+
+\membersection{wxDocument::OnCreate}
+
+\func{virtual bool}{OnCreate}{\param{const wxString\& }{path}, \param{long}{ flags}}
+
+Called just after the document object is created to give it a chance
+to initialize itself. The default implementation uses the
+template associated with the document to create an initial view.
+If this function returns FALSE, the document is deleted.
+
+\membersection{wxDocument::OnCreateCommandProcessor}
+
+\func{virtual wxCommandProcessor*}{OnCreateCommandProcessor}{\void}
+
+Override this function if you want a different (or no) command processor
+to be created when the document is created. By default, it returns
+an instance of wxCommandProcessor.
+
+See \helpref{wxCommandProcessor}{wxcommandprocessor}.
+
+\membersection{wxDocument::OnNewDocument}
+
+\func{virtual bool}{OnNewDocument}{\void}
+
+The default implementation calls OnSaveModified and DeleteContents, makes a default title for the
+document, and notifies the views that the filename (in fact, the title) has changed.
+
+\membersection{wxDocument::OnOpenDocument}
+
+\func{virtual bool}{OnOpenDocument}{\param{const wxString\& }{filename}}
+
+Constructs an input file stream for the given filename (which must not be NULL),
+and calls LoadObject. If LoadObject returns TRUE, the document is set to
+unmodified; otherwise, an error message box is displayed. The document's
+views are notified that the filename has changed, to give windows an opportunity
+to update their titles. All of the document's views are then updated.
+
+\membersection{wxDocument::OnSaveDocument}
+
+\func{virtual bool}{OnSaveDocument}{\param{const wxString\& }{filename}}
+
+Constructs an output file stream for the given filename (which must not be NULL),
+and calls SaveObject. If SaveObject returns TRUE, the document is set to
+unmodified; otherwise, an error message box is displayed.
+
+\membersection{wxDocument::OnSaveModified}
+
+\func{virtual bool}{OnSaveModified}{\void}
+
+If the document has been modified, prompts the user to ask if the changes should
+be changed. If the user replies Yes, the Save function is called. If No, the
+document is marked as unmodified and the function succeeds. If Cancel, the
+function fails.
+
+\membersection{wxDocument::RemoveView}
+
+\func{virtual bool}{RemoveView}{\param{wxView* }{view}}
+
+Removes the view from the document's list of views, and calls OnChangedViewList.
+
+\membersection{wxDocument::Save}
+
+\func{virtual bool}{Save}{\void}
+
+Saves the document by calling OnSaveDocument if there is an associated filename,
+or SaveAs if there is no filename.
+
+\membersection{wxDocument::SaveAs}
+
+\func{virtual bool}{SaveAs}{\void}
+
+Prompts the user for a file to save to, and then calls OnSaveDocument.
+
+\membersection{wxDocument::SaveObject}
+
+\func{virtual ostream\&}{SaveObject}{\param{ostream\& }{stream}}
+
+Override this function and call it from your own SaveObject before
+streaming your own data. SaveObject is called by the framework
+automatically when the document contents need to be saved.
+
+\membersection{wxDocument::SetCommandProcessor}
+
+\func{virtual void}{SetCommandProcessor}{\param{wxCommandProcessor *}{processor}}
+
+Sets the command processor to be used for this document. The document will then be responsible
+for its deletion. Normally you should not call this; override OnCreateCommandProcessor
+instead.
+
+See \helpref{wxCommandProcessor}{wxcommandprocessor}.
+
+\membersection{wxDocument::SetDocumentName}
+
+\func{void}{SetDocumentName}{\param{const wxString\& }{name}}
+
+Sets the document type name for this document. See the comment for \helpref{documentTypeName}{documenttypename}.
+
+\membersection{wxDocument::SetDocumentTemplate}
+
+\func{void}{SetDocumentTemplate}{\param{wxDocTemplate* }{templ}}
+
+Sets the pointer to the template that created the document. Should only be called by the
+framework.
+
+\membersection{wxDocument::SetFilename}
+
+\func{void}{SetFilename}{\param{const wxString\& }{filename}}
+
+Sets the filename for this document. Usually called by the framework.
+
+\membersection{wxDocument::SetTitle}
+
+\func{void}{SetTitle}{\param{const wxString\& }{title}}
+
+Sets the title for this document. The document title is used for an associated
+frame (if any), and is usually constructed by the framework from
+the filename.
+
+\membersection{wxDocument::UpdateAllViews}\label{wxdocumentupdateallviews}
+
+\func{void}{UpdateAllViews}{\param{wxView* }{sender = NULL}}
+
+Updates all views. If {\it sender} is non-NULL, does not update this view.

docs/latex/wx/dropevt.tex

@@ -0,0 +1,72 @@
+\section{\class{wxDropFilesEvent}}\label{wxdropfilesevent}
+
+This class is used for drop files events, that is, when files have been dropped
+onto the window. This functionality is currently only available under Windows.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+To process a drop files event, use these event handler macros to direct input to a member
+function that takes a wxDropFilesEvent argument.
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_DROP\_FILES(func)}}{Process a wxEVT\_DROP\_FILES event.}
+\end{twocollist}%
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnDropFiles}{wxwindowondropfiles}, \helpref{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDropFilesEvent::wxDropFilesEvent}
+
+\func{}{wxDropFilesEvent}{\param{WXTYPE }{id = 0}, \param{int }{noFiles = 0},\rtfsp
+\param{wxString* }{files = NULL}}
+
+Constructor.
+
+\membersection{wxDropFilesEvent::m\_files}
+
+\member{wxString*}{m\_files}
+
+An array of filenames.
+
+\membersection{wxDropFilesEvent::m\_noFiles}
+
+\member{int}{m\_noFiles}
+
+The number of files dropped.
+
+\membersection{wxDropFilesEvent::m\_pos}
+
+\member{wxPoint}{m\_pos}
+
+The point at which the drop took place.
+
+\membersection{wxDropFilesEvent::GetFiles}\label{wxdropfileseventgetfiles}
+
+\constfunc{wxString*}{GetFiles}{\void}
+
+Returns an array of filenames.
+
+\membersection{wxDropFilesEvent::GetNumberOfFiles}\label{wxdropfileseventgetnumberoffiles}
+
+\constfunc{int}{GetNumberOfFiles}{\void}
+
+Returns the number of files dropped.
+
+\membersection{wxDropFilesEvent::GetPosition}\label{wxdropfileseventgetposition}
+
+\constfunc{wxPoint}{GetPosition}{\void}
+
+Returns the position at which the files were dropped.
+
+Returns an array of filenames.
+
+

docs/latex/wx/eraseevt.tex

@@ -0,0 +1,48 @@
+\section{\class{wxEraseEvent}}\label{wxeraseevent}
+
+An erase event is sent when a window's background needs to be repainted.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+To process an erase event, use this event handler macro to direct input to a member
+function that takes a wxEraseEvent argument.
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_ERASE\_BACKGROUND(func)}}{Process a wxEVT\_ERASE\_BACKGROUND event.}
+\end{twocollist}%
+
+\wxheading{Remarks}
+
+If the {\bf m\_DC} member is non-NULL, draw into this device context.
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnEraseBackground}{wxwindowonerasebackground}, \helpref{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxEraseEvent::wxEraseEvent}
+
+\func{}{wxEraseEvent}{\param{int }{id = 0}, \param{wxDC* }{dc = NULL}}
+
+Constructor.
+
+\membersection{wxEraseEvent::m\_dc}
+
+\member{wxDC*}{m\_dc}
+
+The device context associated with the erase event (may be NULL).
+
+\membersection{wxEraseEvent::GetDC}\label{wxeraseeventgetdc}
+
+\constfunc{wxDC*}{GetDC}{\void}
+
+Returns the device context to draw into. If this is non-NULL, you should draw
+into it to perform the erase operation.
+

docs/latex/wx/event.tex

@@ -0,0 +1,141 @@
+\section{\class{wxEvent}}\label{wxevent}
+
+An event is a structure holding information about an event passed to a
+callback or member function. {\bf wxEvent} used to be a multipurpose
+event object, and is an abstract base class for other event classes (see below).
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxCommandEvent}{wxcommandevent},\rtfsp
+\helpref{wxMouseEvent}{wxmouseevent}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxEvent::wxEvent}
+
+\func{}{wxEvent}{\param{int }{id = 0}}
+
+Constructor. Should not need to be used directly by an application.
+
+\membersection{wxEvent::m\_eventHandle}
+
+\member{char*}{m\_eventHandle}
+
+Handle of an underlying windowing system event handle, such as
+XEvent. Not guaranteed to be instantiated.
+
+\membersection{wxEvent::m\_eventObject}
+
+\member{wxObject*}{m\_eventObject}
+
+The object (usually a window) that the event was generated from,
+or should be sent to.
+
+\membersection{wxEvent::m\_eventType}
+
+\member{WXTYPE}{m\_eventType}
+
+The type of the event, such as wxEVENT\_TYPE\_BUTTON\_COMMAND.
+
+\membersection{wxEvent::m\_id}
+
+\member{int}{m\_id}
+
+Identifier for the window.
+
+\membersection{wxEvent::m\_skipped}
+
+\member{bool}{m\_skipped}
+
+Set to TRUE by {\bf Skip} if this event should be skipped.
+
+\membersection{wxEvent::m\_timeStamp}
+
+\member{long}{m\_timeStamp}
+
+Timestamp for this event.
+
+\membersection{wxEvent::GetEventClass}
+
+\func{WXTYPE}{GetEventClass}{\void}
+
+Returns the identifier of the given event class,
+such as wxTYPE\_MOUSE\_EVENT.
+
+\membersection{wxEvent::GetEventObject}
+
+\func{wxObject*}{GetEventObject}{\void}
+
+Returns the object associated with the
+event, if any.
+
+\membersection{wxEvent::GetEventType}
+
+\func{WXTYPE}{GetEventType}{\void}
+
+Returns the identifier of the given event type,
+such as wxEVENT\_TYPE\_BUTTON\_COMMAND.
+
+\membersection{wxEvent::GetId}
+
+\func{int}{GetId}{\void}
+
+Returns the identifier associated with this event, such as a button command id.
+
+\membersection{wxEvent::GetObjectType}
+
+\func{WXTYPE}{GetObjectType}{\void}
+
+Returns the type of the object associated with the
+event, such as wxTYPE\_BUTTON.
+
+\membersection{wxEvent::GetSkipped}
+
+\func{bool}{GetSkipped}{\void}
+
+Returns TRUE if the event handler should be skipped, FALSE otherwise.
+
+\membersection{wxEvent::GetTimestamp}
+
+\func{long}{GetTimestamp}{\void}
+
+Gets the timestamp for the event.
+
+\membersection{wxEvent::SetEventObject}
+
+\func{void}{SetEventObject}{\param{wxObject* }{object}}
+
+Sets the originating object.
+
+\membersection{wxEvent::SetEventType}
+
+\func{void}{SetEventType}{\param{WXTYPE }{typ}}
+
+Sets the event type.
+
+\membersection{wxEvent::SetId}
+
+\func{void}{SetId}{\param{int}{ id}}
+
+Sets the identifier associated with this event, such as a button command id.
+
+\membersection{wxEvent::SetTimestamp}
+
+\func{void}{SetTimestamp}{\param{long }{timeStamp}}
+
+Sets the timestamp for the event.
+
+Sets the originating object.
+
+\membersection{wxEvent::Skip}\label{wxeventskip}
+
+\func{void}{Skip}{\param{bool}{ skip = TRUE}}
+
+Called by an event handler to tell the event system that the
+event handler should be skipped, and the next valid handler used
+instead.
+

docs/latex/wx/evthand.tex

@@ -0,0 +1,269 @@
+\section{\class{wxEvtHandler}}\label{wxevthandler}
+
+A class that can handle events from the windowing system.
+wxWindow (and therefore all window classes) are derived from
+this class.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\overview{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxEvtHandler::wxEvtHandler}
+
+\func{}{wxEvtHandler}{\void}
+
+Constructor.
+
+\membersection{wxEvtHandler::\destruct{wxEvtHandler}}
+
+\func{}{\destruct{wxEvtHandler}}{\void}
+
+Destructor. 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.
+
+\membersection{wxEvtHandler::Default}\label{wxevthandlerdefault}
+
+\func{virtual long}{Default}{\void}
+
+Invokes default processing if this event handler is a window.
+
+\wxheading{Return value}
+
+System dependent.
+
+\wxheading{Remarks}
+
+A generic way of delegating processing to the default system behaviour. It calls a platform-dependent
+default function, with parameters dependent on the event or message parameters
+originally sent from the windowing system.
+
+Normally the application should call a base member, such as \helpref{wxWindow::OnChar}{wxwindowonchar}, which itself
+may call {\bf Default}.
+
+\membersection{wxEvtHandler::GetClientData}\label{wxevthandlergetclientdata}
+
+\func{char* }{GetClientData}{\void}
+
+Gets user-supplied client data.
+
+\wxheading{Remarks}
+
+Normally, any extra data the programmer wishes to associate with the object
+should be made available by deriving a new class
+with new data members.
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::SetClientData}{wxevthandlersetclientdata}
+
+\membersection{wxEvtHandler::GetEvtHandlerEnabled}\label{wxevthandlergetevthandlerenabled}
+
+\func{bool}{GetEvtHandlerEnabled}{\void}
+
+Returns TRUE if the event handler is enabled, FALSE otherwise.
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::SetEvtHandlerEnabled}{wxevthandlersetevthandlerenabled}
+
+\membersection{wxEvtHandler::GetNextHandler}\label{wxevthandlergetnexthandler}
+
+\func{wxEvtHandler*}{GetNextHandler}{\void}
+
+Gets the pointer to the next handler in the chain.
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::GetPreviousHandler}{wxevthandlergetprevioushandler},\rtfsp
+\helpref{wxEvtHandler::SetPreviousHandler}{wxevthandlersetprevioushandler},\rtfsp
+\helpref{wxEvtHandler::SetNextHandler}{wxevthandlersetnexthandler},\rtfsp
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxWindow::PopEventHandler}{wxwindowpopeventhandler}
+
+\membersection{wxEvtHandler::GetPreviousHandler}\label{wxevthandlergetprevioushandler}
+
+\func{wxEvtHandler*}{GetPreviousHandler}{\void}
+
+Gets the pointer to the previous handler in the chain.
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::GetPreviousHandler}{wxevthandlergetprevioushandler},\rtfsp
+\helpref{wxEvtHandler::SetPreviousHandler}{wxevthandlersetprevioushandler},\rtfsp
+\helpref{wxEvtHandler::SetPreviousHandler}{wxevthandlersetprevioushandler},\rtfsp
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxWindow::PopEventHandler}{wxwindowpopeventhandler}
+
+\membersection{wxEvtHandler::ProcessEvent}\label{wxevthandlerprocessevent}
+
+\func{virtual bool}{ProcessEvent}{\param{wxEvent\& }{event}}
+
+Processes an event, searching event tables and calling zero or more suitable event handler function(s).
+
+\wxheading{Parameters}
+
+\docparam{event}{Event to process.}
+
+\wxheading{Return value}
+
+TRUE if a suitable event handler function was found and executed, and the function did not
+call \helpref{wxEvent::Skip}{wxeventskip}.
+
+\wxheading{Remarks}
+
+Normally, your application would not call this function: it is called in the wxWindows
+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 {\bf 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, {\bf 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 (wxProperty) also overrides {\bf ProcessEvent} for similar reasons.
+
+The normal order of event table searching is as follows:
+
+\begin{enumerate}\itemsep=0pt
+\item If the object is disabled (via a call to \helpref{wxEvtHandler::SetEvtHandlerEnabled}{wxevthandlersetevthandlerenabled})
+the function skips to step (6).
+\item If the object is a wxWindow, {\bf ProcessEvent} is recursively called on the window's\rtfsp
+\helpref{wxValidator}{wxvalidator}. If this returns TRUE, the function exits.
+\item {\bf 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.
+\item 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.
+\item If the object is a wxWindow and the event is a wxCommandEvent, {\bf ProcessEvent} is
+recursively applied to the parent window's event handler. If this returns TRUE, the function exits.
+\item Finally, {\bf ProcessEvent} is called on the wxApp object.
+\end{enumerate}
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::SearchEventTable}{wxevthandlersearcheventtable}
+
+\membersection{wxEvtHandler::SearchEventTable}\label{wxevthandlersearcheventtable}
+
+\func{bool}{SearchEventTable}{\param{wxEventTable\& }{table}, \param{wxEvent\& }{event}}
+
+Searches the event table, executing an event handler function if an appropriate one
+is found.
+
+\wxheading{Parameters}
+
+\docparam{table}{Event table to be searched.}
+
+\docparam{event}{Event to be matched against an event table entry.}
+
+\wxheading{Return value}
+
+TRUE if a suitable event handler function was found and executed, and the function did not
+call \helpref{wxEvent::Skip}{wxeventskip}.
+
+\wxheading{Remarks}
+
+This function looks through the object's event table and tries to find an entry
+that will match the event.
+
+An entry will match if:
+
+\begin{enumerate}\itemsep=0pt
+\item The event type matches, and
+\item the identifier or identifier range matches, or the event table entry's identifier is zero.
+\end{enumerate}
+
+If a suitable function is called but calls \helpref{wxEvent::Skip}{wxeventskip}, this function will
+fail, and searching will continue.
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::ProcessEvent}{wxevthandlerprocessevent}
+
+\membersection{wxEvtHandler::SetClientData}\label{wxevthandlersetclientdata}
+
+\func{void}{SetClientData}{\param{char* }{data}}
+
+Sets user-supplied client data.
+
+\wxheading{Parameters}
+
+\docparam{data}{Data to be associated with the event handler.}
+
+\wxheading{Remarks}
+
+Normally, any extra data the programmer wishes
+to associate with the object should be made available by deriving a new class
+with new data members.
+
+TODO: make this void*, char* only in compatibility mode.
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::GetClientData}{wxevthandlergetclientdata}
+
+\membersection{wxEvtHandler::SetEvtHandlerEnabled}\label{wxevthandlersetevthandlerenabled}
+
+\func{void}{SetEvtHandlerEnabled}{\param{bool }{enabled}}
+
+Enables or disables the event handler.
+
+\wxheading{Parameters}
+
+\docparam{enabled}{TRUE if the event handler is to be enabled, FALSE if it is to be disabled.}
+
+\wxheading{Remarks}
+
+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.
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::GetEvtHandlerEnabled}{wxevthandlergetevthandlerenabled}
+
+\membersection{wxEvtHandler::SetNextHandler}\label{wxevthandlersetnexthandler}
+
+\func{void}{SetNextHandler}{\param{wxEvtHandler* }{handler}}
+
+Sets the pointer to the next handler.
+
+\wxheading{Parameters}
+
+\docparam{handler}{Event handler to be set as the next handler.}
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::GetNextHandler}{wxevthandlergetnexthandler},\rtfsp
+\helpref{wxEvtHandler::SetPreviousHandler}{wxevthandlersetprevioushandler},\rtfsp
+\helpref{wxEvtHandler::GetPreviousHandler}{wxevthandlergetprevioushandler},\rtfsp
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxWindow::PopEventHandler}{wxwindowpopeventhandler}
+
+\membersection{wxEvtHandler::SetPreviousHandler}\label{wxevthandlersetprevioushandler}
+
+\func{void}{SetPreviousHandler}{\param{wxEvtHandler* }{handler}}
+
+Sets the pointer to the previous handler.
+
+\wxheading{Parameters}
+
+\docparam{handler}{Event handler to be set as the previous handler.}
+
+\wxheading{See also}
+
+\helpref{wxEvtHandler::GetPreviousHandler}{wxevthandlergetprevioushandler},\rtfsp
+\helpref{wxEvtHandler::SetNextHandler}{wxevthandlersetnexthandler},\rtfsp
+\helpref{wxEvtHandler::GetNextHandler}{wxevthandlergetnexthandler},\rtfsp
+\helpref{wxWindow::PushEventHandler}{wxwindowpusheventhandler},\rtfsp
+\helpref{wxWindow::PopEventHandler}{wxwindowpopeventhandler}
+
+

docs/latex/wx/expr.tex

@@ -0,0 +1,505 @@
+\section{\class{wxExpr}}\label{wxexpr}
+
+The {\bf wxExpr} class is the building brick of expressions similar to Prolog
+clauses, or objects. It can represent an expression of type long integer, float, string, word,
+or list, and lists can be nested.
+
+\wxheading{Derived from}
+
+None
+
+\wxheading{See also}
+
+\helpref{wxExpr overview}{exproverview}, \helpref{wxExprDatabase}{wxexprdatabase}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxExpr::wxExpr}\label{wxexprconstr}
+
+\func{}{wxExpr}{\param{const wxString\&}{functor}}
+
+Construct a new clause with this form, supplying the functor name. A clause is an object
+that will appear in the data file, with a list of attribute/value pairs.
+
+\func{}{wxExpr}{\param{wxExprType}{ type}, \param{const wxString\&}{ wordOrString = ``"}}
+
+Construct a new empty list, or a word (will be output with no quotes), or a string, depending on the
+value of {\it type}.
+
+{\it type} can be {\bf wxExprList}, {\bf wxExprWord}, or {\bf wxExprString}. If {\it type} is wxExprList,
+the value of {\it wordOrString} will be ignored.
+
+\func{}{wxExpr}{\param{long}{ value}}
+
+Construct an integer expression.
+
+\func{}{wxExpr}{\param{float}{ value}}
+
+Construct a floating point expression.
+
+\func{}{wxExpr}{\param{wxList* }{value}}
+
+Construct a list expression. The list's nodes' data should
+themselves be {\bf wxExpr}s.
+
+The current version of this library no longer uses the {\bf wxList}
+internally, so this constructor turns the list into its internal
+format (assuming a non-nested list) and then deletes the supplied
+list.
+
+\membersection{wxExpr::\destruct{wxExpr}}
+
+\func{}{\destruct{wxExpr}}{\void}
+
+Destructor.
+
+\membersection{wxExpr::AddAttributeValue}\label{wxexpraddattributevalue}
+
+Use these on clauses ONLY. Note that the functions for adding strings
+and words must be differentiated by function name which is why
+they are missing from this group (see \helpref{wxExpr::AddAttributeValueString}{wxexpraddattributevaluestring} and
+\rtfsp\helpref{wxExpr::AddAttributeValueWord}{wxexpraddattributevalueword}).
+
+\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{float }{value}}
+
+Adds an attribute and floating point value pair to the clause.
+
+\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{long }{value}}
+
+Adds an attribute and long integer value pair to the clause.
+
+\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxList* }{value}}
+
+Adds an attribute and list value pair to the clause, converting the list into
+internal form and then deleting {\bf value}. Note that the list should not contain
+nested lists (except if in internal {\bf wxExpr} form.)
+
+\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxExpr* }{value}}
+
+Adds an attribute and wxExpr value pair to the clause. Do not delete\rtfsp
+{\it value} once this function has been called.
+
+\membersection{wxExpr::AddAttributeValueString}\label{wxexpraddattributevaluestring}
+
+\func{void}{AddAttributeValueString}{\param{const wxString\&}{ attribute}, \param{const wxString\&}{ value}}
+
+Adds an attribute and string value pair to the clause.
+
+\membersection{wxExpr::AddAttributeValueStringList}\label{wxexpraddattributevaluestringlist}
+
+\func{void}{AddAttributeValueStringList}{\param{const wxString\&}{ attribute}, \param{wxList* }{value}}
+
+Adds an attribute and string list value pair to the clause.
+
+Note that the list passed to this function is a list of strings, NOT a list
+of {\bf wxExpr}s; it gets turned into a list of {\bf wxExpr}s
+automatically. This is a convenience function, since lists of strings
+are often manipulated in C++.
+
+\membersection{wxExpr::AddAttributeValueWord}\label{wxexpraddattributevalueword}
+
+\func{void}{AddAttributeValueWord}{\param{const wxString\&}{ attribute}, \param{const wxString\&}{ value}}
+
+Adds an attribute and word value pair to the clause.
+
+\membersection{wxExpr::Append}\label{wxexprappend}
+
+\func{void}{Append}{\param{wxExpr*}{ value}}
+
+Append the {\bf value} to the end of the list. `this' must be a list.
+
+\membersection{wxExpr::Arg}\label{wxexprarg}
+
+\constfunc{wxExpr* }{Arg}{\param{wxExprType}{ type}, \param{int}{ n}}
+
+Get nth arg of the given clause (starting from 1). NULL is returned if
+the expression is not a clause, or {\it n} is invalid, or the given type
+does not match the actual type. See also \helpref{wxExpr::Nth}{wxexprnth}.
+
+\membersection{wxExpr::Insert}\label{wxexprinsert}
+
+\func{void}{Insert}{\param{wxExpr* }{value}}
+
+Insert the {\bf value} at the start of the list. `this' must be a list.
+
+\membersection{wxExpr::GetAttributeValue}\label{wxexprgetattributevalue}
+
+These functions are the easiest way to retrieve attribute values, by
+passing a pointer to variable. If the attribute is present, the
+variable will be filled with the appropriate value.  If not, the
+existing value is left alone.  This style of retrieving attributes
+makes it easy to set variables to default values before calling these
+functions; no code is necessary to check whether the attribute is
+present or not.
+
+\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxString\&}{ value}}
+
+Retrieve a string (or word) value.
+
+\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{float\& }{value}}
+
+Retrieve a floating point value.
+
+\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{int\& }{value}}
+
+Retrieve an integer value.
+
+\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{long\& }{value}}
+
+Retrieve a long integer value.
+
+\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxExpr**}{ value}}
+
+Retrieve a wxExpr pointer.
+
+\membersection{wxExpr::GetAttributeValueStringList}\label{wxexprgetattributestringlist}
+
+\constfunc{void}{GetAttributeValueStringList}{\param{const wxString\&}{attribute}, \param{wxList* }{value}}
+
+Use this on clauses ONLY. See above for comments on this style of
+attribute value retrieval. This function expects to receive a pointer to
+a new list (created by the calling application); it will append strings
+to the list if the attribute is present in the clause.
+
+\membersection{wxExpr::AttributeValue}\label{wxexprattributevalue}
+
+\constfunc{wxExpr*}{AttributeValue}{\param{const wxString\&}{ word}}
+
+Use this on clauses ONLY. Searches the clause for an attribute
+matching {\it word}, and returns the value associated with it.
+
+\membersection{wxExpr::Copy}\label{wxexprcopy}
+
+\constfunc{wxExpr*}{Copy}{\void}
+
+Recursively copies the expression, allocating new storage space.
+
+\membersection{wxExpr::DeleteAttributeValue}\label{wxexprdeletattributevalue}
+
+\func{void}{DeleteAttributeValue}{\param{const wxString\&}{ attribute}}
+
+Use this on clauses only. Deletes the attribute and its value (if any) from the
+clause.
+
+\membersection{wxExpr::Functor}\label{wxexprfunctor}
+
+\constfunc{wxString}{Functor}{\void}
+
+Use this on clauses only. Returns the clause's functor (object name).
+
+\membersection{wxExpr::GetClientData}\label{wxexprgetclientdata}
+
+\constfunc{wxObject*}{GetClientData}{\void}
+
+Retrieve arbitrary data stored with this clause. This can be useful when
+reading in data for storing a pointer to the C++ object, so when another
+clause makes a reference to this clause, its C++ object can be retrieved.
+See \helpref{wxExpr::SetClientData}{wxexprsetclientdata}.
+
+\membersection{wxExpr::GetFirst}\label{wxexprgetfirst}
+
+\constfunc{wxExpr*}{GetFirst}{\void}
+
+If this is a list expression (or clause), gets the first element in the list.
+
+See also \helpref{wxExpr::GetLast}{wxexprgetlast}, \helpref{wxExpr::GetNext}{wxexprgetnext}, \helpref{wxExpr::Nth}{wxexprnth}.
+
+\membersection{wxExpr::GetLast}\label{wxexprgetlast}
+
+\constfunc{wxExpr*}{GetLast}{\void}
+
+If this is a list expression (or clause), gets the last element in the list.
+
+See also \helpref{wxExpr::GetFirst}{wxexprgetfirst}, \helpref{wxExpr::GetNext}{wxexprgetnext}, \helpref{wxExpr::Nth}{wxexprnth}.
+
+\membersection{wxExpr::GetNext}\label{wxexprgetnext}
+
+\constfunc{wxExpr*}{GetNext}{\void}
+
+If this is a node in a list (any wxExpr may be a node in a list), gets the
+next element in the list.
+
+See also \helpref{wxExpr::GetFirst}{wxexprgetfirst}, \helpref{wxExpr::GetLast}{wxexprgetlast}, \helpref{wxExpr::Nth}{wxexprnth}.
+
+\membersection{wxExpr::IntegerValue}\label{wxexprintegervalue}
+
+\constfunc{long}{IntegerValue}{\void}
+
+Returns the integer value of the expression.
+
+\membersection{wxExpr::Nth}\label{wxexprnth}
+
+\constfunc{wxExpr*}{Nth}{\param{int}{ n}}
+
+Get nth arg of the given list expression (starting from 0). NULL is returned if
+the expression is not a list expression, or {\it n} is invalid. See also \helpref{wxExpr::Arg}{wxexprarg}.
+
+Normally, you would use attribute-value pairs to add and retrieve data
+from objects (clauses) in a data file. However, if the data gets complex,
+you may need to store attribute values as lists, and pick them apart
+yourself.
+
+\membersection{wxExpr::RealValue}\label{wxexprrealvalue}
+
+\constfunc{float}{RealValue}{\void}
+
+Returns the floating point value of the expression.
+
+\membersection{wxExpr::SetClientData}\label{wxexprsetclientdata}
+
+\func{void}{SetClientData}{\param{wxObject *}{data}}
+
+Associate arbitrary data with this clause. This can be useful when
+reading in data for storing a pointer to the C++ object, so when another
+clause makes a reference to this clause, its C++ object can be retrieved.
+See \helpref{wxExpr::GetClientData}{wxexprgetclientdata}.
+
+\membersection{wxExpr::StringValue}\label{wxexprstringvalue}
+
+\constfunc{wxString}{StringValue}{\void}
+
+Returns the string value of the expression.
+
+\membersection{wxExpr::Type}\label{wxexprtype}
+
+\constfunc{wxExprType}{Type}{\void}
+
+Returns the type of the expression. {\bf wxExprType} is defined as follows:
+
+\begin{verbatim}
+typedef enum {
+    wxExprNull,
+    wxExprInteger,
+    wxExprReal,
+    wxExprWord,
+    wxExprString,
+    wxExprList
+} wxExprType;
+\end{verbatim}
+
+\membersection{wxExpr::WordValue}\label{wxexprwordvalue}
+
+\constfunc{wxString}{WordValue}{\void}
+
+Returns the word value of the expression.
+
+\membersection{wxExpr::WriteLispExpr}\label{wxexprwritelistexpr}
+
+\func{void}{WriteLispExpr}{\param{ostream\&}{ stream}}
+
+Writes the expression or clause to the given stream in LISP format.
+Not normally needed, since the whole {\bf wxExprDatabase} will usually
+be written at once. Lists are enclosed in parentheses will no commas.
+
+\membersection{wxExpr::WritePrologClause}\label{wxexprwriteprologclause}
+
+\func{void}{WritePrologClause}{\param{ostream\&}{ stream}}
+
+Writes the clause to the given stream in Prolog format. Not normally needed, since
+the whole {\bf wxExprDatabase} will usually be written at once. The format is:
+functor, open parenthesis, list of comma-separated expressions, close parenthesis,
+full stop.
+
+\membersection{wxExpr::WriteExpr}\label{wxexprwriteexpr}
+
+\func{void}{WriteExpr}{\param{ostream\&}{ stream}}
+
+Writes the expression (not clause) to the given stream in Prolog
+format. Not normally needed, since the whole {\bf wxExprDatabase} will
+usually be written at once. Lists are written in square bracketed,
+comma-delimited format.
+
+\membersection{Functions and macros}
+
+Below are miscellaneous functions and macros associated with wxExpr objects.
+
+\func{bool}{wxExprIsFunctor}{\param{wxExpr *}{expr}, \param{const wxString\&}{ functor}}
+
+Checks that the functor of {\it expr} is {\it functor}.
+
+\func{void}{wxExprCleanUp}{\void}
+
+Cleans up the wxExpr system (YACC/LEX buffers) to avoid memory-checking warnings as the program exits.
+
+\begin{verbatim}
+#define wxMakeInteger(x) (new wxExpr((long)x))
+#define wxMakeReal(x)    (new wxExpr((float)x))
+#define wxMakeString(x)  (new wxExpr(PrologString, x))
+#define wxMakeWord(x)    (new wxExpr(PrologWord, x))
+#define wxMake(x)        (new wxExpr(x))
+\end{verbatim}
+
+Macros to help make wxExpr objects.
+
+\section{\class{wxExprDatabase}}\label{wxexprdatabase}
+
+The {\bf wxExprDatabase} class represents a database, or list,
+of Prolog-like expressions.  Instances of this class are used for reading,
+writing and creating data files.
+
+\wxheading{Derived from}
+
+\helpref{wxList}{wxlist}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxExpr overview}{exproverview}, \helpref{wxExpr}{wxexpr}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxExprDatabase::wxExprDatabase}\label{wxexprdatabaseconstr}
+
+\func{void}{wxExprDatabase}{\param{proioErrorHandler}{ handler = 0}}
+
+Construct a new, unhashed database, with an optional error handler. The
+error handler must be a function returning a bool and taking an integer and a string
+argument. When an error occurs when reading or writing a database, this function is
+called. The error is given as the first argument (currently one of WXEXPR\_ERROR\_GENERAL,
+WXEXPR\_ERROR\_SYNTAX) and an error message is given as the second argument. If FALSE
+is returned by the error handler, processing of the wxExpr operation stops.
+
+Another way of handling errors is simply to call \helpref{wxExprDatabase::GetErrorCount}{wxexprdatabasegeterrorcount} after
+the operation, to check whether errors have occurred, instead of installing an error handler.
+If the error count is more than zero, \helpref{wxExprDatabase::Write}{wxexprdatabasewrite} and
+\rtfsp\helpref{wxExprDatabase::Read}{wxexprdatabaseread} will return FALSE to
+the application.
+
+For example:
+
+\begin{verbatim}
+bool myErrorHandler(int err, chat *msg)
+{
+  if (err == WXEXPR_ERROR_SYNTAX)
+  {
+    wxMessageBox(msg, "Syntax error");
+  }
+  return FALSE;
+}
+
+wxExprDatabase database(myErrorHandler);
+\end{verbatim}
+
+
+\func{}{wxExprDatabase}{\param{wxExprType}{ type}, \param{const wxString\&}{attribute},
+\rtfsp\param{int}{ size = 500}, \param{proioErrorHandler}{ handler = 0}}
+
+Construct a new database hashed on a combination of the clause functor and
+a named attribute (often an integer identification).
+
+See above for an explanation of the error handler.
+
+\membersection{wxExprDatabase::\destruct{wxExprDatabase}}
+
+\func{}{\destruct{wxExprDatabase}}{\void}
+
+Delete the database and contents.
+
+\membersection{wxExprDatabase::Append}\label{wxexprdatabaseappend}
+
+\func{void}{Append}{\param{wxExpr* }{clause}}
+
+Append a clause to the end of the database. If the database is hashing,
+the functor and a user-specified attribute will be hashed upon, giving the
+option of random access in addition to linear traversal of the database.
+
+\membersection{wxExprDatabase::BeginFind}\label{wxexprdatabasebeginfind}
+
+\func{void}{BeginFind}{\void}
+
+Reset the current position to the start of the database. Subsequent
+\rtfsp\helpref{wxExprDatabase::FindClause}{wxexprdatabasefindclause} calls will move the pointer.
+
+\membersection{wxExprDatabase::ClearDatabase}\label{wxexprdatabasecleardatabase}
+
+\func{void}{ClearDatabase}{\void}
+
+Clears the contents of the database.
+
+\membersection{wxExprDatabase::FindClause}\label{wxexprdatabasefindclause}
+
+Various ways of retrieving clauses from the database. A return
+value of NULL indicates no (more) clauses matching the given criteria.
+Calling the functions repeatedly retrieves more matching clauses, if any.
+
+\func{wxExpr* }{FindClause}{\param{long}{ id}}
+
+Find a clause based on the special ``id'' attribute.
+
+\func{wxExpr* }{FindClause}{\param{const wxString\&}{ attribute}, \param{const wxString\&}{ value}}
+
+Find a clause which has the given attribute set to the given string or word value.
+
+\func{wxExpr*}{FindClause}{\param{const wxString\&}{ attribute}, \param{long}{ value}}
+
+Find a clause which has the given attribute set to the given integer value.
+
+\func{wxExpr*}{FindClause}{\param{const wxString\&}{ attribute}, \param{float}{ value}}
+
+Find a clause which has the given attribute set to the given floating point value.
+
+\membersection{wxExprDatabase::FindClauseByFunctor}\label{wxexprdatabasefindclausebyfunctor}
+
+\func{wxExpr*}{FindClauseByFunctor}{\param{const wxString\&}{ functor}}
+
+Find the next clause with the specified functor.
+
+\membersection{wxExprDatabase::GetErrorCount}\label{wxexprdatabasegeterrorcount}
+
+\constfunc{int}{GetErrorCount}{\void}
+
+Returns the number of errors encountered during the last read or write operation.
+
+\membersection{wxExprDatabase::HashFind}\label{wxexprdatabasehashfind}
+
+\constfunc{wxExpr*}{HashFind}{\param{const wxString\&}{ functor}, \param{long}{ value}}
+
+Finds the clause with the given functor and with the attribute specified
+in the database constructor having the given integer value.
+
+For example,
+
+\begin{verbatim}
+// Hash on a combination of functor and integer "id" attribute when reading in
+wxExprDatabase db(wxExprInteger, "id");
+
+// Read it in
+db.ReadProlog("data");
+
+// Retrieve a clause with specified functor and id
+wxExpr *clause = db.HashFind("node", 24);
+\end{verbatim}
+
+This would retrieve a clause which is written: {\tt node(id = 24, ..., )}.
+
+\func{wxExpr*}{HashFind}{\param{const wxString\&}{ functor}, \param{const wxString\&}{ value}}
+
+Finds the clause with the given functor and with the attribute specified
+in the database constructor having the given string value.
+
+\membersection{wxExprDatabase::Read}\label{wxexprdatabaseread}
+
+\func{bool}{Read}{\param{const wxString\&}{ filename}}
+
+Reads in the given file, returning TRUE if successful.
+
+\membersection{wxExprDatabase::ReadFromString}\label{wxexprdatabasereadfromstring}
+
+\func{bool}{ReadFromString}{\param{const wxString\&}{ buffer}}
+
+Reads a Prolog database from the given string buffer, returning TRUE if
+successful.
+
+\membersection{wxExprDatabase::WriteLisp}\label{wxexprdatabasewritelisp}
+
+\func{bool}{WriteLisp}{\param{ostream\& }{stream}}
+
+Writes the database as a LISP-format file.
+
+\membersection{wxExprDatabase::Write}\label{wxexprdatabasewrite}
+
+\func{bool}{Write}{\param{ostream\& }{stream}}
+
+Writes the database as a Prolog-format file.
+
+

docs/latex/wx/file.tex

@@ -0,0 +1,169 @@
+\section{\class{wxFile}}\label{wxfile}
+
+A wxFile performs raw file I/O. Note that wxFile::Flush is not implemented on some Windows compilers
+due to a missing fsync function, which reduces the usefulness of this class.
+
+\wxheading{Derived from}
+
+None.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFile::wxFile}\label{wxfileconstr}
+
+\func{}{wxFile}{\void}
+
+Default constructor.
+
+\func{}{wxFile}{\param{const char*}{ filename}, \param{wxFile::OpenMode}{ mode = wxFile::read}}
+
+Opens a file with the given mode.
+
+\func{}{wxFile}{\param{int}{ fd}}
+
+Opens a file with the given file descriptor, which has already been opened.
+
+\wxheading{Parameters}
+
+\docparam{filename}{The filename.}
+
+\docparam{mode}{The mode in which to open the file. May be one of {\bf wxFile::read}, {\bf wxFile::write} and {\bf wxFile::read\_write}.}
+
+\docparam{fd}{An existing file descriptor.}
+
+\membersection{wxFile::\destruct{wxFile}}
+
+\func{}{\destruct{wxFile}}{\void}
+
+Destructor. This is not virtual, for efficiency.
+
+\membersection{wxFile::Attach}\label{wxfileattach}
+
+\func{void}{Attach}{\param{int}{ fd}}
+
+Attaches an existing file descriptor to the wxFile object.
+
+\membersection{wxFile::Close}\label{wxfileclose}
+
+\func{void}{Close}{\void}
+
+Closes the file.
+
+\membersection{wxFile::Create}\label{wxfilecreate}
+
+\func{bool}{Create}{\param{const char*}{ filename}, \param{bool}{ overwrite = FALSE}}
+
+Creates a file for writing. If the file already exists, setting {\bf overwrite} to TRUE
+will ensure it is overwritten.
+
+\membersection{wxFile::Eof}\label{wxfileeof}
+
+\constfunc{bool}{Eof}{\void}
+
+Returns TRUE if the end of the file has been reached.
+
+\membersection{wxFile::Exists}\label{wxfileexists}
+
+\func{static bool}{Exists}{\param{const char*}{ filename}}
+
+Returns TRUE if the file exists.
+
+\membersection{wxFile::Flush}\label{wxfileflush}
+
+\func{bool}{Flush}{\void}
+
+Flushes the file descriptor. Not implemented for some Windows compilers.
+
+\membersection{wxFile::IsOpened}\label{wxfileisopened}
+
+\constfunc{bool}{IsOpened}{\void}
+
+Returns TRUE if the file has been opened.
+
+\membersection{wxFile::Length}\label{wxfilelength}
+
+\constfunc{off\_t}{Length}{\void}
+
+Returns the length of the file.
+
+\membersection{wxFile::Open}\label{wxfileopen}
+
+\func{bool}{Open}{\param{const char*}{ filename}, \param{wxFile::OpenMode}{ mode = wxFile::read}}
+
+Opens the file, returning TRUE if successful.
+
+\wxheading{Parameters}
+
+\docparam{filename}{The filename.}
+
+\docparam{mode}{The mode in which to open the file. May be one of {\bf wxFile::read}, {\bf wxFile::write} and {\bf wxFile::read\_write}.}
+
+\membersection{wxFile::Read}\label{wxfileread}
+
+\func{off\_t}{Read}{\param{void*}{ buffer}, \param{off\_t}{ count}}
+
+Reads the specified number of bytes into a buffer, returning the actual number read.
+
+\wxheading{Parameters}
+
+\docparam{buffer}{A buffer to receive the data.}
+
+\docparam{count}{The number of bytes to read.}
+
+\wxheading{Return value}
+
+The number of bytes read, or the symbol {\bf ofsInvalid} (-1) if there was an error.
+
+\membersection{wxFile::Seek}\label{wxfileseek}
+
+\func{off\_t}{Seek}{\param{off\_t }{ofs}, \param{wxFile::SeekMode }{mode = wxFile::FromStart}}
+
+Seeks to the specified position.
+
+\wxheading{Parameters}
+
+\docparam{ofs}{Offset to seek to.}
+
+\docparam{mode}{One of {\bf wxFile::FromStart}, {\bf wxFile::FromEnd}, {\bf wxFile::FromCurrent}.}
+
+\wxheading{Return value}
+
+The actual offset position achieved, or ofsInvalid on failure.
+
+\membersection{wxFile::SeekEnd}\label{wxfileseekend}
+
+\func{off\_t}{SeekEnd}{\param{off\_t }{ofs = 0}}
+
+Moves the file pointer to the specified number of bytes before the end of the file.
+
+\wxheading{Parameters}
+
+\docparam{ofs}{Number of bytes before the end of the file.}
+
+\wxheading{Return value}
+
+The actual offset position achieved, or ofsInvalid on failure.
+
+\membersection{wxFile::Tell}\label{wxfiletell}
+
+\constfunc{off\_t}{Tell}{\void}
+
+Returns the current position.
+
+\membersection{wxFile::Write}\label{wxfilewrite}
+
+\func{bool}{Write}{\param{const void*}{ buffer}, \param{off\_t}{ count}}
+
+Writes the specified number of bytes from a buffer.
+
+\wxheading{Parameters}
+
+\docparam{buffer}{A buffer containing the data.}
+
+\docparam{count}{The number of bytes to write.}
+
+\wxheading{Return value}
+
+TRUE if the operation was successful.
+
+

docs/latex/wx/filedlg.tex

@@ -0,0 +1,179 @@
+\section{\class{wxFileDialog}}\label{wxfiledialog}
+
+This class represents the file chooser dialog.
+
+\wxheading{Derived from}
+
+\helpref{wxDialog}{wxdialog}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxFileDialog overview}{wxfiledialogoverview}, \helpref{wxFileSelector}{wxfileselector}
+%\rtfsp\helpref{wxFileSelectorEx}{wxfileselectorex}
+%\helpref{wxLoadFileSelector}{wxloadfileselector},\rtfsp
+%\helpref{wxSaveFileSelector}{wxsavefileselector}
+
+\wxheading{Remarks}
+
+Pops up a file selector box. In Windows, this is the common file selector
+dialog. In X, this is a file selector box with somewhat less functionality.
+The path and filename are distinct elements of a full file pathname.
+If path is ``", the current directory will be used. If filename is ``",
+no default filename will be supplied. The wildcard determines what files
+are displayed in the file selector, and file extension supplies a type
+extension for the required filename. Flags may be a combination of wxOPEN,
+wxSAVE, wxOVERWRITE\_PROMPT, wxHIDE\_READONLY, or 0. They are only significant
+at present in Windows.
+
+Both the X and Windows versions implement a wildcard filter. Typing a
+filename containing wildcards (*, ?) in the filename text item, and
+clicking on Ok, will result in only those files matching the pattern being
+displayed. In the X version, supplying no default name will result in the
+wildcard filter being inserted in the filename text item; the filter is
+ignored if a default name is supplied.
+
+Under Windows (only), the wildcard may be a specification for multiple
+types of file with a description for each, such as:
+
+\begin{verbatim}
+ "BMP files (*.bmp) | *.bmp | GIF files (*.gif) | *.gif"
+\end{verbatim}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFileDialog::wxFileDialog}\label{wxfiledialogconstr}
+
+\func{}{wxFileDialog}{\param{wxWindow* }{parent}, \param{const wxString\& }{message = "Choose a file"},\rtfsp
+\param{const wxString\& }{defaultDir = ""}, \param{const wxString\& }{defaultFile = ``"},\rtfsp
+\param{const wxString\& }{wildcard = ``*.*"}, \param{long }{style = 0}, \param{const wxPoint\& }{pos = wxDefaultPosition}}
+
+Constructor. Use \helpref{wxFileDialog::ShowModal}{wxfiledialogshowmodal} to show the dialog.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window.}
+
+\docparam{message}{Message to show on the dialog.}
+
+\docparam{defaultDir}{The default directory, or the empty string.}
+
+\docparam{defaultFile}{The default filename, or the empty string.}
+
+\docparam{wildcard}{A wildcard, such as ``*.*".}
+
+\docparam{style}{A dialog style. A bitlist of:
+
+\twocolwidtha{5cm}
+\begin{twocollist}
+\twocolitem{{\bf wxOPEN}}{This is an open dialog (Windows only).}
+\twocolitem{{\bf wxSAVE}}{This is a save dialog (Windows only).}
+\twocolitem{{\bf wxHIDE\_READONLY}}{Hide read-only files (Windows only).}
+\twocolitem{{\bf wxOVERWRITE\_PROMPT}}{Prompt for a conformation if a file will be overridden (Windows only).}
+\end{twocollist}%
+}
+
+\docparam{pos}{Dialog position. Not implemented.}
+
+\membersection{wxFileDialog::\destruct{wxFileDialog}}
+
+\func{}{\destruct{wxFileDialog}}{\void}
+
+Destructor.
+
+\membersection{wxFileDialog::GetDirectory}\label{wxfiledialoggetdirectory}
+
+\constfunc{wxString}{GetDirectory}{\void}
+
+Returns the default directory.
+
+\membersection{wxFileDialog::GetFilename}\label{wxfiledialoggetfilename}
+
+\constfunc{wxString}{GetFilename}{\void}
+
+Returns the default filename.
+
+\membersection{wxFileDialog::GetFilterIndex}\label{wxfiledialoggetfilterindex}
+
+\constfunc{int}{GetFilterIndex}{\void}
+
+Returns the index into the list of filters supplied, optionally, in the wildcard parameter.
+Before the dialog is shown, this is the index which will be used when the dialog is first displayed.
+After the dialog is shown, this is the index selected by the user.
+
+\membersection{wxFileDialog::GetMessage}\label{wxfiledialoggetmessage}
+
+\constfunc{wxString}{GetMessage}{\void}
+
+Returns the message that will be displayed on the dialog.
+
+\membersection{wxFileDialog::GetPath}\label{wxfiledialoggetpath}
+
+\constfunc{wxString}{GetPath}{\void}
+
+Returns the full path (directory and filename) of the selected file.
+
+\membersection{wxFileDialog::GetStyle}\label{wxfiledialoggetstyle}
+
+\constfunc{long}{GetStyle}{\void}
+
+Returns the dialog style.
+
+\membersection{wxFileDialog::GetWildcard}\label{wxfiledialoggetwildcard}
+
+\constfunc{wxString}{GetWildcard}{\void}
+
+Returns the file dialog wildcard.
+
+\membersection{wxFileDialog::SetDirectory}\label{wxfiledialogsetdirectory}
+
+\func{void}{SetDirectory}{\param{const wxString\& }{directory}}
+
+Sets the default directory.
+
+\membersection{wxFileDialog::SetFilename}\label{wxfiledialogsetfilename}
+
+\func{void}{SetFilename}{\param{const wxString\& }{setfilename}}
+
+Sets the default filename.
+
+\membersection{wxFileDialog::SetFilterIndex}\label{wxfiledialogsetfilterindex}
+
+\func{void}{SetFilterIndex}{\param{int }{filterIndex}}
+
+Sets the default filter index, starting from zero. Windows only.
+
+\membersection{wxFileDialog::SetMessage}\label{wxfiledialogsetmessage}
+
+\func{void}{SetMessage}{\param{const wxString\& }{message}}
+
+Sets the message that will be displayed on the dialog.
+
+\membersection{wxFileDialog::SetPath}\label{wxfiledialogsetpath}
+
+\func{void}{SetPath}{\param{const wxString\& }{path}}
+
+Sets the path (the combined directory and filename that will be returned when the dialog is dismissed).
+
+\membersection{wxFileDialog::SetStyle}\label{wxfiledialogsetstyle}
+
+\func{void}{SetStyle}{\param{long }{style}}
+
+Sets the dialog style. See \helpref{wxFileDialog::wxFileDialog}{wxfiledialogconstr} for details.
+
+\membersection{wxFileDialog::SetWildcard}\label{wxfiledialogsetwildcard}
+
+\func{void}{SetWildcard}{\param{const wxString\& }{wildCard}}
+
+Sets the wildcard, which in Windows can contain multiple file types.
+
+\membersection{wxFileDialog::ShowModal}\label{wxfiledialogshowmodal}
+
+\func{int}{ShowModal}{\void}
+
+Shows the dialog, returning wxID\_OK if the user pressed OK, and wxOK\_CANCEL
+otherwise.
+
+

docs/latex/wx/filehist.tex

@@ -0,0 +1,124 @@
+\section{\class{wxFileHistory}}\label{wxfilehistory}
+
+The wxFileHistory encapsulates a user interface convenience, the
+list of most recently visited files as shown on a menu (usually the File menu).
+
+wxFileHistory can manage one or more file menus. More than one menu may be required
+in an MDI application, where the file history should appear on each MDI child menu
+as well as the MDI parent frame.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxFileHistory overview}{wxfilehistoryoverview}, \helpref{wxDocManager}{wxdocmanager}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFileHistory::m\_fileHistory}
+
+\member{char**}{m\_fileHistory}
+
+A character array of strings corresponding to the most recently opened
+files.
+
+\membersection{wxFileHistory::m\_fileHistoryN}
+
+\member{int}{m\_fileHistoryN}
+
+The number of files stored in the history array.
+
+\membersection{wxFileHistory::m\_fileMaxFiles}
+
+\member{int}{m\_fileMaxFiles}
+
+The maximum number of files to be stored and displayed on the menu.
+
+\membersection{wxFileHistory::m\_fileMenu}
+
+\member{wxMenu*}{m\_fileMenu}
+
+The file menu used to display the file history list (if enabled).
+
+\membersection{wxFileHistory::wxFileHistory}
+
+\func{}{wxFileHistory}{\param{int}{ maxFiles = 9}}
+
+Constructor. Pass the maximum number of files that should be stored and displayed.
+
+\membersection{wxFileHistory::\destruct{wxFileHistory}}
+
+\func{}{\destruct{wxFileHistory}}{\void}
+
+Destructor.
+
+\membersection{wxFileHistory::AddFileToHistory}
+
+\func{void}{AddFileToHistory}{\param{const wxString\& }{filename}}
+
+Adds a file to the file history list, if the object has a pointer to an appropriate file menu.
+
+\membersection{wxFileHistory::AddFilesToMenu}\label{wxfilehistoryaddfilestomenu}
+
+\func{void}{AddFilesToMenu}{\void}
+
+Appends the files in the history list, to all menus managed by the file history object.
+
+\func{void}{AddFilesToMenu}{\param{wxMenu*}{ menu}}
+
+Appends the files in the history list, to the given menu only.
+
+\membersection{wxFileHistory::GetHistoryFile}\label{wxfilehistorygethistoryfile}
+
+\constfunc{wxString}{GetHistoryFile}{\param{int}{ index}}
+
+Returns the file at this index (zero-based).
+
+\membersection{wxFileHistory::GetMaxFiles}
+
+\constfunc{int}{GetMaxFiles}{\void}
+
+Returns the maximum number of files that can be stored.
+
+\membersection{wxFileHistory::GetNoHistoryFiles}
+
+\constfunc{int}{GetNoHistoryFiles}{\void}
+
+Returns the number of files currently stored in the file history.
+
+\membersection{wxFileHistory::Load}
+
+\func{void}{Load}{\param{wxConfigBase\& }{config}}
+
+Loads the file history from the given config object. This function should be called explicitly by the application.
+
+\wxheading{See also}
+
+\helpref{wxConfig}{wxconfigbase}
+
+\membersection{wxFileHistory::RemoveMenu}
+
+\func{void}{RemoveMenu}{\param{wxMenu* }{menu}}
+
+Removes this menu from the list of those managed by this object.
+
+\membersection{wxFileHistory::Save}
+
+\func{void}{Save}{\param{wxConfigBase\& }{config}}
+
+Saves the file history into the given config object. This must be called
+explicitly by the application.
+
+\wxheading{See also}
+
+\helpref{wxConfig}{wxconfigbase}
+
+\membersection{wxFileHistory::UseMenu}
+
+\func{void}{UseMenu}{\param{wxMenu* }{menu}}
+
+Adds this menu to the list of those managed by this object.
+
+

docs/latex/wx/focusevt.tex

@@ -0,0 +1,34 @@
+\section{\class{wxFocusEvent}}\label{wxfocusevent}
+
+A focus event is sent when a window's focus changes.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+To process a focus event, use these event handler macros to direct input to a member
+function that takes a wxFocusEvent argument.
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_SET\_FOCUS(func)}}{Process a wxEVT\_SET\_FOCUS event.}
+\twocolitem{{\bf EVT\_KILL\_FOCUS(func)}}{Process a wxEVT\_KILL\_FOCUS event.}
+\end{twocollist}%
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnSetFocus}{wxwindowonsetfocus},\rtfsp
+\helpref{wxWindow::OnKillFocus}{wxwindowonkillfocus},\rtfsp
+\helpref{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFocusEvent::wxFocusEvent}
+
+\func{}{wxFocusEvent}{\param{WXTYPE }{eventType = 0}, \param{int }{id = 0}}
+
+Constructor.
+

docs/latex/wx/font.tex

@@ -0,0 +1,277 @@
+\section{\class{wxFont}}\label{wxfont}
+
+A font is an object which determines the appearance of text. Fonts are
+used for drawing text to a device context, and setting the appearance of
+a window's text.
+
+\wxheading{Derived from}
+
+\helpref{wxGDIObject}{wxgdiobject}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxFont overview}{wxfontoverview}, \helpref{wxDC::SetFont}{wxdcsetfont},\rtfsp
+\helpref{wxDC::DrawText}{wxdcdrawtext}, \helpref{wxDC::GetTextExtent}{wxdcgettextextent},\rtfsp
+\helpref{wxFontDialog}{wxfontdialog}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFont::wxFont}\label{wxfontconstr}
+
+\func{}{wxFont}{\void}
+
+Default constructor.
+
+\func{}{wxFont}{\param{int}{ pointSize}, \param{int}{ family}, \param{int}{ style}, \param{int}{ weight},
+ \param{const bool}{ underline = FALSE}, \param{const wxString\& }{faceName = ""}}
+
+Creates a font object.
+
+\wxheading{Parameters}
+
+\docparam{pointSize}{Size in points.}
+
+\docparam{family}{Font family, a generic way of referring to fonts without specifying actual facename. One of:
+
+\twocolwidtha{5cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxDEFAULT}}{Chooses a default font.}
+\twocolitem{{\bf wxDECORATIVE}}{A decorative font.}
+\twocolitem{{\bf wxROMAN}}{A formal, serif font.}
+\twocolitem{{\bf wxSCRIPT}}{A handwriting font.}
+\twocolitem{{\bf wxSWISS}}{A sans-serif font.}
+\twocolitem{{\bf wxMODERN}}{A fixed pitch font.}
+\end{twocollist}}
+
+\docparam{style}{One of {\bf wxNORMAL}, {\bf wxSLANT} and {\bf wxITALIC}.}
+
+\docparam{weight}{One of {\bf wxNORMAL}, {\bf wxLIGHT} and {\bf wxBOLD}.}
+
+\docparam{underline}{The value can be TRUE or FALSE. At present this has an effect on Windows only.}
+
+\docparam{faceName}{An optional string specifying the actual typeface to be used. If the empty string,
+a default typeface will chosen based on the family.}
+
+\wxheading{Remarks}
+
+If the desired font does not exist, the closest match will be chosen.
+Under Windows, only scaleable TrueType fonts are used.
+
+Underlining only works under Windows at present.
+
+See also \helpref{wxDC::SetFont}{wxdcsetfont}, \helpref{wxDC::DrawText}{wxdcdrawtext}
+and \helpref{wxDC::GetTextExtent}{wxdcgettextextent}.
+
+\membersection{wxFont::\destruct{wxFont}}
+
+\func{}{\destruct{wxFont}}{\void}
+
+Destructor.
+
+\wxheading{Remarks}
+
+The destructor may not delete the underlying font object of the native windowing
+system, since wxBrush uses a reference counting system for efficiency.
+
+Although all remaining fonts are deleted when the application exits,
+the application should try to clean up all fonts itself. This is because
+wxWindows cannot know if a pointer to the font object is stored in an
+application data structure, and there is a risk of double deletion.
+
+\membersection{wxFont::GetFaceName}\label{wxfontgetfacename}
+
+\constfunc{wxString}{GetFaceName}{\void}
+
+Returns the typeface name associated with the font, or the empty string if there is no
+typeface information.
+
+\wxheading{See also}
+
+\helpref{wxFont::SetFaceName}{wxfontsetfacename}
+
+\membersection{wxFont::GetFamily}\label{wxfontgetfamily}
+
+\constfunc{int}{GetFamily}{\void}
+
+Gets the font family. See \helpref{wxFont::wxFont}{wxfontconstr} for a list of valid
+family identifiers.
+
+\wxheading{See also}
+
+\helpref{wxFont::SetFamily}{wxfontsetfamily}
+
+\membersection{wxFont::GetFontId}\label{wxfontgetfontid}
+
+\constfunc{int}{GetFontId}{\void}
+
+Returns the font id, if the portable font system is in operation. See \helpref{Font overview}{wxfontoverview} for
+further details.
+
+\membersection{wxFont::GetPointSize}\label{wxfontgetpointsize}
+
+\constfunc{int}{GetPointSize}{\void}
+
+Gets the point size.
+
+\wxheading{See also}
+
+\helpref{wxFont::SetPointSize}{wxfontsetpointsize}
+
+\membersection{wxFont::GetStyle}\label{wxfontgetstyle}
+
+\constfunc{int}{GetStyle}{\void}
+
+Gets the font style. See \helpref{wxFont::wxFont}{wxfontconstr} for a list of valid
+styles.
+
+\wxheading{See also}
+
+\helpref{wxFont::SetStyle}{wxfontsetstyle}
+
+\membersection{wxFont::GetUnderlined}\label{wxfontgetunderlined}
+
+\constfunc{bool}{GetUnderlined}{\void}
+
+Returns TRUE if the font is underlined, FALSE otherwise.
+
+\wxheading{See also}
+
+\helpref{wxFont::SetUnderlined}{wxfontsetunderlined}
+
+\membersection{wxFont::GetWeight}\label{wxfontgetweight}
+
+\constfunc{int}{GetWeight}{\void}
+
+Gets the font weight. See \helpref{wxFont::wxFont}{wxfontconstr} for a list of valid
+weight identifiers.
+
+\wxheading{See also}
+
+\helpref{wxFont::SetWeight}{wxfontsetweight}
+
+\membersection{wxFont::SetFaceName}\label{wxfontsetfacename}
+
+\func{void}{SetFaceName}{\param{const wxString\& }{faceName}}
+
+Sets the facename for the font.
+
+\wxheading{Parameters}
+
+\docparam{faceName}{A valid facename, which should be on the end-user's system.}
+
+\wxheading{Remarks}
+
+To avoid portability problems, don't rely on a specific face, but specify the font family
+instead or as well. A suitable font will be found on the end-user's system. If both the
+family and the facename are specified, wxWindows will first search for the specific face,
+and then for a font belonging to the same family.
+
+\wxheading{See also}
+
+\helpref{wxFont::GetFaceName}{wxfontgetfacename}, \helpref{wxFont::SetFamily}{wxfontsetfamily}
+
+\membersection{wxFont::SetFamily}\label{wxfontsetfamily}
+
+\func{void}{SetFamily}{\param{int}{ family}}
+
+Sets the font family.
+
+\wxheading{Parameters}
+
+\docparam{family}{One of:
+
+\twocolwidtha{5cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxDEFAULT}}{Chooses a default font.}
+\twocolitem{{\bf wxDECORATIVE}}{A decorative font.}
+\twocolitem{{\bf wxROMAN}}{A formal, serif font.}
+\twocolitem{{\bf wxSCRIPT}}{A handwriting font.}
+\twocolitem{{\bf wxSWISS}}{A sans-serif font.}
+\twocolitem{{\bf wxMODERN}}{A fixed pitch font.}
+\end{twocollist}}
+
+\wxheading{See also}
+
+\helpref{wxFont::GetFamily}{wxfontgetfamily}, \helpref{wxFont::SetFaceName}{wxfontsetfacename}
+
+\membersection{wxFont::SetPointSize}\label{wxfontsetpointsize}
+
+\func{void}{SetPointSize}{\param{int}{ pointSize}}
+
+Sets the point size.
+
+\wxheading{Parameters}
+
+\docparam{pointSize}{Size in points.}
+
+\wxheading{See also}
+
+\helpref{wxFont::GetPointSize}{wxfontgetpointsize}
+
+\membersection{wxFont::SetStyle}\label{wxfontsetstyle}
+
+\func{void}{SetStyle}{\param{int}{ style}}
+
+Sets the font style.
+
+\wxheading{Parameters}
+
+\docparam{style}{One of {\bf wxNORMAL}, {\bf wxSLANT} and {\bf wxITALIC}.}
+
+\wxheading{See also}
+
+\helpref{wxFont::GetStyle}{wxfontgetstyle}
+
+\membersection{wxFont::SetUnderlined}\label{wxfontsetunderlined}
+
+\func{void}{SetUnderlined}{\param{const bool}{ underlined}}
+
+Sets underlining.
+
+\wxheading{Parameters}
+
+\docparam{underlining}{TRUE to underline, FALSE otherwise.}
+
+\wxheading{See also}
+
+\helpref{wxFont::GetUnderlined}{wxfontgetunderlined}
+
+\membersection{wxFont::SetWeight}\label{wxfontsetweight}
+
+\func{void}{SetWeight}{\param{int}{ weight}}
+
+Sets the font weight.
+
+\wxheading{Parameters}
+
+\docparam{weight}{One of {\bf wxNORMAL}, {\bf wxLIGHT} and {\bf wxBOLD}.}
+
+\wxheading{See also}
+
+\helpref{wxFont::GetWeight}{wxfontgetweight}
+
+\membersection{wxFont::operator $=$}\label{wxfontassignment}
+
+\func{wxFont\&}{operator $=$}{\param{const wxFont\& }{font}}
+
+Assignment operator, using reference counting. Returns a reference
+to `this'.
+
+\membersection{wxFont::operator $==$}\label{wxfontequals}
+
+\func{bool}{operator $==$}{\param{const wxFont\& }{font}}
+
+Equality operator. Two fonts are equal if they contain pointers
+to the same underlying font data. It does not compare each attribute,
+so two indefontdently-created fonts using the same parameters will
+fail the test.
+
+\membersection{wxFont::operator $!=$}\label{wxfontnotequals}
+
+\func{bool}{operator $!=$}{\param{const wxFont\& }{font}}
+
+Inequality operator. Two fonts are not equal if they contain pointers
+to different underlying font data. It does not compare each attribute.
+
+

docs/latex/wx/fontdlg.tex

@@ -0,0 +1,187 @@
+\section{\class{wxFontData}}\label{wxfontdata}
+
+\overview{wxFontDialog overview}{wxfontdialogoverview}
+
+This class holds a variety of information related to font dialogs.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Overview}{wxfontdialogoverview}, \helpref{wxFontDialog}{wxfontdialog}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFontData::wxFontData}
+
+\func{}{wxFontData}{\void}
+
+Constructor. Initializes {\it fontColour} to black, {\it showHelp} to black,
+\rtfsp{\it allowSymbols} to TRUE, {\it enableEffects} to TRUE,
+\rtfsp{\it minSize} to 0 and {\it maxSize} to 0.
+
+\membersection{wxFontData::\destruct{wxFontData}}
+
+\func{}{\destruct{wxFontData}}{\void}
+
+Destructor.
+
+\membersection{wxFontData::EnableEffects}
+
+\func{void}{EnableEffects}{\param{bool}{ enable}}
+
+Enables or disables `effects' under MS Windows only. This refers to the
+controls for manipulating colour, strikeout and underline properties.
+
+The default value is TRUE.
+
+\membersection{wxFontData::GetAllowSymbols}
+
+\func{bool}{GetAllowSymbols}{\void}
+
+Under MS Windows, returns a flag determining whether symbol fonts can be selected. Has no
+effect on other platforms.
+
+The default value is TRUE.
+
+\membersection{wxFontData::GetColour}
+
+\func{wxColour\&}{GetColour}{\void}
+
+Gets the colour associated with the font dialog.
+
+The default value is black.
+
+\membersection{wxFontData::GetChosenFont}
+
+\func{wxFont}{GetChosenFont}{\void}
+
+Gets the font chosen by the user. If the user pressed OK (wxFontDialog::Show returned TRUE), this returns
+a new font which is now `owned' by the application, and should be deleted
+if not required. If the user pressed Cancel (wxFontDialog::Show returned FALSE) or
+the colour dialog has not been invoked yet, this will return NULL.
+
+\membersection{wxFontData::GetEnableEffects}
+
+\func{bool}{GetEnableEffects}{\void}
+
+Determines whether `effects' are enabled under Windows. This refers to the
+controls for manipulating colour, strikeout and underline properties.
+
+The default value is TRUE.
+
+\membersection{wxFontData::GetInitialFont}
+
+\func{wxFont}{GetInitialFont}{\void}
+
+Gets the font that will be initially used by the font dialog. This should have
+previously been set by the application.
+
+\membersection{wxFontData::GetShowHelp}
+
+\func{bool}{GetShowHelp}{\void}
+
+Returns TRUE if the Help button will be shown (Windows only).
+
+The default value is FALSE.
+
+\membersection{wxFontData::SetAllowSymbols}
+
+\func{void}{SetAllowSymbols}{\param{bool}{ allowSymbols}}
+
+Under MS Windows, determines whether symbol fonts can be selected. Has no
+effect on other platforms.
+
+The default value is TRUE.
+
+\membersection{wxFontData::SetChosenFont}
+
+\func{void}{SetChosenFont}{\param{const wxFont\& }{font}}
+
+Sets the font that will be returned to the user (for internal use only).
+
+\membersection{wxFontData::SetColour}
+
+\func{void}{SetColour}{\param{const wxColour\&}{ colour}}
+
+Sets the colour that will be used for the font foreground colour.
+
+The default colour is black.
+
+\membersection{wxFontData::SetInitialFont}
+
+\func{void}{SetInitialFont}{\param{const wxFont\&}{font}}
+
+Sets the font that will be initially used by the font dialog.
+
+\membersection{wxFontData::SetRange}
+
+\func{void}{SetRange}{\param{int}{ min}, \param{int}{ max}}
+
+Sets the valid range for the font point size (Windows only).
+
+The default is 0, 0 (unrestricted range).
+
+\membersection{wxFontData::SetShowHelp}
+
+\func{void}{SetShowHelp}{\param{bool}{ showHelp}}
+
+Determines whether the Help button will be displayed in the font dialog (Windows only).
+
+The default value is FALSE.
+
+\membersection{wxFontData::operator $=$}
+
+\func{void}{operator $=$}{\param{const wxFontData\&}{ data}}
+
+Assingment operator for the font data.
+
+\section{\class{wxFontDialog}}\label{wxfontdialog}
+
+This class represents the font chooser dialog.
+
+\wxheading{Derived from}
+
+\helpref{wxDialog}{wxdialog}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Overview}{wxfontdialogoverview}, \helpref{wxFontData}{wxfontdata}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFontDialog::wxFontDialog}
+
+\func{}{wxFontDialog}{\param{wxWindow* }{parent}, \param{wxFontData* }{data = NULL}}
+
+Constructor. Pass a parent window, and optionally a pointer to a block of font
+data, which will be copied to the font dialog's font data.
+
+\membersection{wxFontDialog::\destruct{wxFontDialog}}
+
+\func{}{\destruct{wxFontDialog}}{\void}
+
+Destructor.
+
+\membersection{wxFontDialog::GetFontData}
+
+\func{wxFontData\&}{GetFontData}{\void}
+
+Returns the \helpref{font data}{wxfontdata} associated with the font dialog.
+
+\membersection{wxFontDialog::ShowModal}
+
+\func{int}{ShowModal}{\void}
+
+Shows the dialog, returning wxID\_OK if the user pressed Ok, and wxID\_CANCEL
+otherwise.
+
+If the user cancels the dialog (ShowModal returns wxID\_CANCEL), no font will be
+created. If the user presses OK (ShowModal returns wxID\_OK), a new wxFont will
+be created and stored in the font dialog's wxFontData structure.
+

docs/latex/wx/fontlist.tex

@@ -0,0 +1,48 @@
+\section{\class{wxFontList}}\label{wxfontlist}
+
+A font list is a list containing all fonts which have been created. There
+is only one instance of this class: {\bf wxTheFontList}.  Use this object to search
+for a previously created font of the desired type and create it if not already found.
+In some windowing systems, the font may be a scarce resource, so it is best to
+reuse old resources if possible.  When an application finishes, all fonts will be
+deleted and their resources freed, eliminating the possibility of `memory leaks'.
+
+\wxheading{Derived from}
+
+\helpref{wxList}{wxlist}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{wxFont}{wxfont}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxFontList::wxFontList}
+
+\func{}{wxFontList}{\void}
+
+Constructor. The application should not construct its own font list:
+use the object pointer {\bf wxTheFontList}.
+
+\membersection{wxFontList::AddFont}
+
+\func{void}{AddFont}{\param{wxFont *}{font}}
+
+Used by wxWindows to add a font to the list, called in the font constructor.
+
+\membersection{wxFontList::FindOrCreateFont}\label{findorcreatefont}
+
+\func{wxFont *}{FindOrCreateFont}{\param{int}{ point\_size}, \param{int}{ family}, \param{int}{ style}, \param{int}{ weight}, \param{bool}{ underline = FALSE},
+ \param{const wxString\& }{facename = NULL}}
+
+Finds a font of the given specification, or creates one and adds it to the list. See the \helpref{wxFont constructor}{wxfontconstr} for
+details of the arguments.
+
+\membersection{wxFontList::RemoveFont}
+
+\func{void}{RemoveFont}{\param{wxFont *}{font}}
+
+Used by wxWindows to remove a font from the list.
+
+