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

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

.cvsignore

@@ -3,6 +3,7 @@ bin
 .gdb_history
 Test
 config.cache
+configarg.cache
 config.status
 system.list
 linux.system.cache
@@ -17,16 +18,18 @@ linux-gnu.system.cache
 *.ncb
 *.pro
 *.opt
+*.d
+*.swp
+*.swo
 Release
 Debug
 ReleaseDLL
 DebugDLL
 robert
-Makefile.in
-setup.h.in
 stamp-h.in
 Makefile
 configure
 setup.h
 stamp-h
 libtool
+aclocal.m4

BuildCVS.txt

@@ -5,58 +5,238 @@
 I) Windows using plain makefiles
 ----------------------------------------
 
-No idea, never did it.
+a) If using Microsoft Visual C++ 5.0 or 6.0
+
+Ensure that the command-line compiler and tools (including
+nmake) are installed and ready to run.  Depending on your
+installation there may be a batch file (named something like
+VCVARS32.BAT) that needs to be run to set correct environment
+varaibles and PATH entries.
+
+Continue with item c) below.
 
 
-II) Unix using plain makefiles.
-----------------------------------------
+b) If using the GNU MinGW32 or GNU CygWin32 compilers
 
-No idea, never did it.
+You'll need the compiler itself which is available from
 
+  http://www.cygwin.com
+
+When using MingW32 you'll need GNU make which is a part
+of the CygWin32 toolchain and is also available as a stand
+alone port without the infamous Cygwin.dll from
+
+  http://agnes.dida.physik.uni-essen.de/~janjaap/mingw32
+
+The makefile has small problems with Cygwin<69>s tools
+so it is recommended not to use these (but MingGW32
+and its make.exe).
+
+-> Set your path so that it includes the directory
+   where your compiler and tools reside
+
+b-2) Using Mingw32 with gcc-2.95 and Anders Norlander's
+     Win32 headers
+
+Using the newer gcc-2.95/Noralander header combination
+will allow you to compile more of the MSW code, such
+as OLE and Drag-n-Drop.
+
+Instructions are similar to those for Regular Mingw32 except
+
+->Get the compiler from
+    ftp://ftp.xraylith.wisc.edu/pub/khan/gnu-win32/mingw32/gcc-2.95/
+
+->patch the gcc headers with info in wxWin\Mingw32-gcc295.patches.
+  PLEASE APPLY THESE PATCHES BY HAND! There are apparently a few
+  different versions of the headers floating around.
+
+->Edit wx/src/makeg95.env and set the MINGW32 variable at the top of
+  the file to either 1 (you have Mingw32) or 0 (you have Cygwin32).
+  If using MINGW32, also set the MINGW32VERSION variable
+  appropriately.
+
+
+c) Build instructions
+
+-> Assumming that you installed the wxWindows sources
+   into c:\wxWin
+-> Copy c:\wxWin\include\wx\msw\setup0.h
+   to   c:\wxWin\include\wx\msw\setup.h
+-> Edit c:\wxWin\include\wx\msw\setup.h so that
+   most features are enabled (i.e. defined to 1) with
+   #define wxUSE_ODBC          0
+   #define wxUSE_SOCKETS       0
+   #define wxUSE_HTML          1
+   #define wxUSE_THREADS       1
+   #define wxUSE_FS_INET       0
+   #define wxUSE_FS_ZIP        1
+   #define wxUSE_BUSYINFO      1
+   #define wxUSE_DYNLIB_CLASS  1
+   #define wxUSE_ZIPSTREAM     1
+   #define wxUSE_LIBJPEG       1
+   #define wxUSE_LIBPNG        1
+
+   and iostreams ares disabled with
+   #define wxUSE_STD_IOSTREAM   0
+
+   note: ODBC and SOCKETS can be 1 for gcc-2.95
+
+-> type: cd c:\wxWin\src\msw
+-> type: make -f makefile.g95  (if using GNU tools)
+or type: make -f makefile.vc   (if using MS VC++)
+
+
+II) Unix ports
+--------------
+
+Building wxGTK or wxMotif completely without configure
+won't ever work, but there is now a new makefile system
+that works without libtool and automake, using only
+configure to create what is needed.
+
+In order to create configure, you need to have the
+GNU autoconf package (version 2.13 or 2.14) installed
+on your system and type run "autoconf" in the base
+directory (or run the autogen.sh script in the same
+directory, which just calls autoconf).
+
+Set WXWIN environment variable to the base directory such
+as ~/wxWindows (this is actually not really needed).
+
+-> type: export WXWIN=~/wxWindows
+-> type: md mybuild
+-> type: cd mybuild
+-> type: ../configure --with-motif
+or type: ../configure --with-gtk
+-> type: make
+-> type: su <type root password>
+-> type: make install
+-> type: ldconfig
+-> type: exit
+
+Call configure with --disable-shared to create a static
+library. Calling "make uninstall" will remove the installed
+library and "make dist" will create a distribution (not
+yet complete).
 
 III) Windows using configure
 ----------------------------------------
 
-No idea..
-
-
-IV) Unix using configure
-----------------------------------------
-
-a) You have all the newest and greatest GNU tools installed on your system 
-and in the same directory hierachy (e.g. either all tools in /usr or all 
-in /usr/local), these tools are:
-- GNU libtool 1.2e (1.3 doesn't work here)
-- GNU autoconf 2.14 (including autoheader 2.14)
-- GNU automake 1.4 (including aclocal 1.4)
-and possibly but not forcibly
-- GNU make 3.76.1
-- GNU C++ (EGCS)
-
--> Go to the base directory
--> type: ./autogen.sh
-
-b) You don't know what autos are and have no driver's licence anyway:
-
--> Go to the testconf directory
--> type: ./apply
-
-a+b) Then proceed in either case with:
-
--> Choose a directory name that seems fit for building wxWindows, e.g. mybuild
--> Go the base directory
--> type: mkdir mybuild
--> type: cd mybuild
--> type: ../configure --with-gtk   
-or type: ../configure --with-motif
-or type: ../configure --with-wine
--> type make
--> drink lots of coffee and go shopping
+Take a look at Unix->Windows cross compiling. With minor
+modifications, this should work in Windows if you've got the cygnus
+utilities (bash, GNU make, etc) and either mingw32 or cygwin32 installed.
+See http://www.cygnus.com for these programs, or go straight to their
+ftp server at ftp://sourceware.cygnus.com/pub/cygwin/.
 
+Of course, you can also build the library using plain makefiles (see
+section I).
 
 V) MacOS
 ----------------------------------------
 
-V) OS/2
+VI) OS/2
 ----------------------------------------
 
+VII) Unix->Windows cross-compiling using configure
+--------------------------------------------------
+
+First you'll need a cross-compiler; linux glibc binaries of mingw32 and
+cygwin32 (both based on egcs) can be found at
+ftp://ftp.objsw.com/pub/crossgcc/linux-x-win32. Otherwise you can
+compile one yourself. Check the relevant FAQs.
+
+[ A Note about cygwin32 and mingw32: the main difference is that cygwin32
+binaries are always linked against cygwin.dll. This dll encapsulates most
+standard Unix C extensions, which is very handy if you're porting unix
+software to windows. However, wxMSW doesn't need this, so mingw32 is
+preferable if you write portable C(++). ]
+
+You might want to build both Unix and Windows binaries in the same source
+tree; to do this make subdirs for each e.g. unix and win32. If you've
+already build wxWindows in the main dir, do a 'make distclean' there,
+otherwise configure will get confused. (In any case, read the section 'Unix
+using configure' and make sure you're able to build a native wxWindows
+library; cross-compiling errors can be pretty obscure and you'll want to be
+sure that your configure setup is basically sound.)
+
+To cross compile the windows library, do
+-> cd win32
+(or whatever you called it)
+Now run configure. There are two ways to do this
+-> ../configure --host=i586-mingw32 --build=i586-linux --with-mingw \
+   --enable-dnd=no --without-odbc
+where --build= should read whatever platform you're building on. Configure
+will notice that build and host platforms differ, and automatically prepend
+i586-mingw32- to gcc, ar, ld, etc (make sure they're in the PATH!).
+The other way to run configure is by specifying the names of the binaries
+yourself:
+-> CC=i586-mingw32-gcc CXX=i586-mingw32-g++ RANLIB=i586-mingw32-ranlib \
+   DLLTOOL=i586-mingw32-dlltool LD=i586-mingw32-ld NM=i586-mingw32-nm \
+   ../configure --host=i586-mingw32 --with-mingw --enable-dnd=no
+
+(all assuming you're using mingw32)
+Drag'n'drop is disabled because mingw32 lacks (AFAIK) OLE headers.
+
+[ Update: some new mingw32 versions now have a new set of windows header
+files, which apparently can handle ole. Untested at the moment ]
+
+ODBC files don't compile as of 13.10.99 - may be this will be fixed by the
+moment you're reading these lines.
+
+Configure will conclude that shared libraries are out of the question and
+opt for a static one. I haven't looked into DLL creation yet.
+
+Type
+-> make
+and wait, wait, wait. Don't leave the room, because the minute you do there
+will be a compile error :-)
+
+NB: you risk to get quite a few warnings about "ANSI C++ forbids implicit
+    conversion from 'void *'" in all places where va_arg macro is used. This
+    is due to a bug in (some versions of) mingw32 headers which may be
+    corrected by editing the file
+
+    ${install_prefix}/lib/gcc-lib/i586-mingw32/egcs-2.91.57/include/stdarg.h
+
+    (instead of egcs-2.91.57 you may have something different), searching for
+    the lines
+
+/* Define __gnuc_va_list.  */
+
+#ifndef __GNUC_VA_LIST
+#define __GNUC_VA_LIST
+#if defined(__svr4__) || defined(_AIX) || defined(_M_UNIX) || defined(__NetBSD__)
+typedef char *__gnuc_va_list;
+#else
+typedef void *__gnuc_va_list;
+#endif
+#endif
+
+    and adding "|| defined(_WIN32)" to the list of platforms on which
+    __gnuc_va_list is char *.
+
+If this is successful, you end up with a libwx_msw.a in win32/lib.  Now try
+building the minimal sample:
+
+-> cd samples/minimal
+-> make
+
+and run it with wine, for example (or copy to a Windows box)
+-> wine minimal.exe
+
+If all is well, do an install; from win32
+-> make install
+
+Native and cross-compiled installations can co-exist peacefully
+(as long as their widget sets differ), except for wx-config. You might
+want to rename the cross-compiled one to i586-mingw32-wx-config, or something.
+
+Cross-compiling TODO:
+---------------------
+- resource compiling must be done manually for now (should/can we link the
+default wx resources into libwx_msw.a?) [ No we can't; the linker won't
+link it in... you have to supply an object file ]
+- dynamic libraries
+- static executables are HUGE -- there must be room for improvement.
+

Makefile.am

@@ -1,13 +0,0 @@
-
-AUTOMAKE_OPTIONS = 1.3 
-# no-dependencies
-
-SUBDIRS = include src samples misc # utils user docs
-
-bin_SCRIPTS = wx-config
-
-configincludedir = $(libdir)/wx/include/wx/$(TOOLKIT_DIR)
-
-configinclude_DATA = \
-	setup.h
-

Mingw32-gcc295.patches

@@ -0,0 +1,131 @@
+*** \gcc-inc\basetyps.h Sat Jul 31 16:48:36 1999
+--- basetyps.h Fri Aug 06 11:14:36 1999
+***************
+*** 74,91 ****
+--- 74,97 ----
+   STDMETHOD(Clone)(IENUM_THIS_(I) I**) PURE; \
+  }
+  #define DECLARE_ENUMERATOR(T) DECLARE_ENUMERATOR_(IEnum##T,T)
+
++ #ifndef GUID_DEFINED
++ #define GUID_DEFINED
+  typedef struct _GUID
+  {
+      unsigned long Data1;
+      unsigned short Data2;
+      unsigned short Data3;
+      unsigned char Data4[8];
+  } GUID;
++ #endif /* GUID_DEFINED */
+  typedef GUID *REFGUID;
+  typedef GUID *LPGUID;
++ #ifndef UUID_DEFINED
++ #define UUID_DEFINED
+  typedef GUID UUID;
++ #endif /* UUID_DEFINED */
+  typedef GUID IID;
+  typedef GUID CLSID;
+  typedef CLSID *LPCLSID;
+  typedef IID *LPIID;
+
+
+*** \gcc-inc\oaidl.h Sat Jul 31 16:48:42 1999
+--- oaidl.h Fri Aug 06 13:18:48 1999
+***************
+*** 39,44 ****
+--- 39,53 ----
+  #define IMPLTYPEFLAG_FRESTRICTED 4
+  #define IMPLTYPEFLAG_FDEFAULTVTABLE 8
+
++ #define DISPID_UNKNOWN ( -1 )
++ #define DISPID_VALUE ( 0 )
++ #define DISPID_PROPERTYPUT ( -3 )
++ #define DISPID_NEWENUM ( -4 )
++ #define DISPID_EVALUATE ( -5 )
++ #define DISPID_CONSTRUCTOR ( -6 )
++ #define DISPID_DESTRUCTOR ( -7 )
++ #define DISPID_COLLECT ( -8 )
++
+  typedef interface ITypeLib *LPTYPELIB;
+  typedef interface ICreateTypeInfo *LPCREATETYPEINFO;
+  typedef interface ICreateTypeInfo2 *LPCREATETYPEINFO2;
+***************
+*** 49,54 ****
+--- 58,73 ----
+  typedef interface IDispatch *LPDISPATCH;
+  typedef interface ICreateErrorInfo *LPCREATEERRORINFO;
+
++ extern "C" const IID IID_ITypeLib;
++ extern "C" const IID IID_ICreateTypeInfo;
++ extern "C" const IID IID_ICreateTypeInfo2;
++ extern "C" const IID IID_ICreateTypeLib;
++ extern "C" const IID IID_ICreateTypeLib2;
++ extern "C" const IID IID_ITypeInfo;
++ extern "C" const IID IID_IErrorInfo;
++ extern "C" const IID IID_IDispatch;
++ extern "C" const IID IID_ICreateErrorInfo;
++
+  typedef enum tagSYSKIND {
+   SYS_WIN16,SYS_WIN32,SYS_MAC
+  } SYSKIND;
+***************
+*** 375,382 ****
+   STDMETHOD_(ULONG,Release)(THIS) PURE;
+   STDMETHOD(GetTypeInfoCount)(THIS_ UINT*) PURE;
+   STDMETHOD(GetTypeInfo)(THIS_ UINT,LCID,LPTYPEINFO*) PURE;
+!  STDMETHOD(GetIDsOfNames)(THIS_ REFIID,LPOLESTR*,UINT,LCID,DISPID)
+PURE;
+!  STDMETHOD(Invoked)(THIS_ DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*) PURE;
+  };
+
+  #ifdef __cplusplus
+--- 394,401 ----
+   STDMETHOD_(ULONG,Release)(THIS) PURE;
+   STDMETHOD(GetTypeInfoCount)(THIS_ UINT*) PURE;
+   STDMETHOD(GetTypeInfo)(THIS_ UINT,LCID,LPTYPEINFO*) PURE;
+!  STDMETHOD(GetIDsOfNames)(THIS_ REFIID,LPOLESTR*,UINT,LCID,DISPID*)
+PURE;
+!  STDMETHOD(Invoke)(THIS_ DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*) PURE;
+  };
+
+  #ifdef __cplusplus
+
+
+*** \gcc-inc\objidl.h Sat Jul 31 16:48:42 1999
+--- objidl.h Fri Aug 06 11:00:19 1999
+***************
+*** 627,633 ****
+   STDMETHOD(QueryGetData)(THIS_ FORMATETC*) PURE;
+   STDMETHOD(GetCanonicalFormatEtc)(THIS_ FORMATETC*,FORMATETC*) PURE;
+   STDMETHOD(SetData)(THIS_ FORMATETC*,STGMEDIUM*,BOOL) PURE;
+!  STDMETHOD(EnumFormatEtc)(THIS_ DWORD,IEnumFORMATETC*) PURE;
+   STDMETHOD(DAdvise)(THIS_ FORMATETC*,DWORD,IAdviseSink*,PDWORD) PURE;
+   STDMETHOD(DUnadvise)(THIS_ DWORD) PURE;
+   STDMETHOD(EnumDAdvise)(THIS_ IEnumSTATDATA**);
+--- 627,633 ----
+   STDMETHOD(QueryGetData)(THIS_ FORMATETC*) PURE;
+   STDMETHOD(GetCanonicalFormatEtc)(THIS_ FORMATETC*,FORMATETC*) PURE;
+   STDMETHOD(SetData)(THIS_ FORMATETC*,STGMEDIUM*,BOOL) PURE;
+!  STDMETHOD(EnumFormatEtc)(THIS_ DWORD,IEnumFORMATETC**) PURE;
+   STDMETHOD(DAdvise)(THIS_ FORMATETC*,DWORD,IAdviseSink*,PDWORD) PURE;
+   STDMETHOD(DUnadvise)(THIS_ DWORD) PURE;
+   STDMETHOD(EnumDAdvise)(THIS_ IEnumSTATDATA**);
+
+
+--- i386-mingw32\include\stdio.h  Sun Aug  1 06:18:20 1999
++++ stdio.h     Sun Nov  7 03:41:40 1999
+@@ -203,9 +203,12 @@
+ int    fprintf (FILE* filePrintTo, const char* szFormat, ...);
+ int    printf (const char* szFormat, ...);
+ int    sprintf (char* caBuffer, const char* szFormat, ...);
++int     _snprintf (char* caBuffer, size_t n, const char* szFormat, ...);
+ int    vfprintf (FILE* filePrintTo, const char* szFormat, va_list varg);
+ int    vprintf (const char* szFormat, va_list varg);
+ int    vsprintf (char* caBuffer, const char* szFormat, va_list varg);
++int     _vsnprintf (char* caBuffer, size_t n, const char* szFormat,
++                    va_list varg);
+
+ /* Wide character versions */
+ int    fwprintf (FILE* filePrintTo, const wchar_t* wsFormat, ...);
+
+

acconfig.h

@@ -1,586 +0,0 @@
-/* Generate setup.h.in from this file using autoheader.                    */
-/*                                                                         */
-/* Version: $Id$                                                           */
-
-#ifndef __GTKSETUPH__
-#define __GTKSETUPH__
-
-#ifdef __GNUG__
-    #pragma interface
-#endif
-
-@TOP@
-
-/* ------------------------------------------------------------------------ */
-/* wxWindows version (not used but required by autoheader)                  */
-/* ------------------------------------------------------------------------ */
-
-/* needed for older automake? */
-#undef WITH_SYMBOL_UNDERSCORE
-
-/* ------------------------------------------------------------------------ */
-/* define if support for GTK 1.2 features                                   */
-/* ------------------------------------------------------------------------ */
-
-#undef __WXGTK12__
-
-/* ------------------------------------------------------------------------ */
-/* define the system to compile                                             */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Define to 1 for Unix[-like] system
- */
-#define wxUSE_UNIX 1
-
-#undef __UNIX__
-#undef __LINUX__
-#undef __SGI__
-#undef __HPUX__
-#undef __SYSV__
-#undef __SVR4__
-#undef __AIX__
-#undef __SUN__
-#undef __SOLARIS__
-#undef __SUNOS__
-#undef __ALPHA__
-#undef __OSF__
-#undef __BSD__
-#undef __FREEBSD__
-#undef __VMS__
-#undef __ULTRIX__
-#undef __DATA_GENERAL__
-#undef __EMX__
-
-#undef __WINDOWS__
-#undef __WIN95__
-#undef __WIN32__
-#undef __GNUWIN32__
-
-/* ------------------------------------------------------------------------ */
-/* compiler options                                                         */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Supports bool type
- */
-#undef HAVE_BOOL
-
-/* ------------------------------------------------------------------------ */
-/* library options                                                          */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use zlib
- */
-#define wxUSE_ZLIB 0
-/*
- * Use libpng
- */
-#define wxUSE_LIBPNG 0
-/*
- * Use libjpeg
- */
-#define wxUSE_LIBJPEG 0
-/*
- * Use libgif
- */
-#define wxUSE_LIBGIF 0
-/*
- * Use iODBC
- */
-#define wxUSE_ODBC 0
-/*
- * Use Threads
- */
-#define wxUSE_THREADS 0
-/*
- * Have glibc2
- */
-#define wxHAVE_GLIBC2 0
-/*
- * Use libXpm
- */
-#define wxHAVE_LIB_XPM 0
-/*
- * Use OpenGL
- */
-#define wxUSE_OPENGL 0
-
-/* ------------------------------------------------------------------------ */
-/* GUI or not GUI?                                                          */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use GUI
- */
-#define wxUSE_GUI 1
-/*
- * Defined if !wxUSE_GUI
- */
-#undef wxUSE_NOGUI
-
-/* ------------------------------------------------------------------------ */
-/* "global" GUI options                                                     */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use constraints mechanism
- */
-#define wxUSE_CONSTRAINTS 0
-
-/*
- * Use validators
- */
-#define wxUSE_VALIDATORS 0
-
-/*
- * Use accelerators
- */
-#define wxUSE_ACCEL 0
-
-/*
- * Use wxTextEntryDialog
- */
-#define wxUSE_TEXTDLG 0
-
-/*
- * Use progress dialog
- */
-#define wxUSE_PROGRESSDLG 0
-
-/*
- * Use directory chooser dialog
- */
-#define wxUSE_DIRDLG 0
-
-/*
- * Joystick support (Linux/GTK only)
- */
-#define wxUSE_JOYSTICK 0
-
-/* ------------------------------------------------------------------------ */
-/* GUI control options                                                      */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use this control
- */
-#define wxUSE_CARET 0
-/*
- * Use this control
- */
-#define wxUSE_BMPBUTTON 0
-/*
- * Use this control
- */
-#define wxUSE_CHECKBOX 0
-/*
- * Use this control
- */
-#define wxUSE_CHECKLISTBOX 0
-/*
- * Use this control
- */
-#define wxUSE_COMBOBOX 0
-/*
- * Use this control
- */
-#define wxUSE_CHOICE 0
-/*
- * Use this control
- */
-#define wxUSE_GAUGE 0
-/*
- * Use this control
- */
-#define wxUSE_GRID 0
-/*
- * Use this control
- */
-#define wxUSE_IMAGLIST 0
-/*
- * Use this control
- */
-#define wxUSE_LISTBOX 0
-/*
- * Use this control
- */
-#define wxUSE_LISTCTRL 0
-/*
- * Use this control
- */
-#define wxUSE_NOTEBOOK 0
-/*
- * Use this control
- */
-#define wxUSE_RADIOBOX 0
-/*
- * Use this control
- */
-#define wxUSE_RADIOBTN 0
-/*
- * Use this control
- */
-#define wxUSE_SASH 0
-/*
- * Use this control
- */
-#define wxUSE_SCROLLBAR 0
-/*
- * Use this control
- */
-#define wxUSE_SLIDER 0
-/*
- * Use this control
- */
-#define wxUSE_SPINBTN 0
-/*
- * Use this control
- */
-#define wxUSE_SPLITTER 0
-/*
- * Use this control
- */
-#define wxUSE_STATBMP 0
-/*
- * Use this control
- */
-#define wxUSE_STATBOX 0
-/*
- * Use this control
- */
-#define wxUSE_STATLINE 0
-/*
- * Use this control
- */
-#define wxUSE_STATUSBAR 0
-/*
- * Use Tab dialog class - obsolete, use wxNotebook instead
- */
-#define wxUSE_TAB_DIALOG 0
-/* compatibility */
-#define wxUSE_TABDIALOG wxUSE_TAB_DIALOG
-/*
- * Use this control
- */
-#define wxUSE_TOOLBAR 0
-
-#ifdef __WXWINE__
-  #if wxUSE_TOOLBAR
-    #define wxUSE_BUTTONBAR 1
-  #endif
-#endif
-
-/*
- * Use this control
- */
-#define wxUSE_TREECTRL 0
-
-/* ------------------------------------------------------------------------ */
-/* non-GUI options                                                          */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use wxLongLong (a.k.a. int64) class
- */
-#define wxUSE_LONGLONG 0
-
-/*
- * Use wxFile class
- */
-#define wxUSE_FILE 0
-/*
- * Use wxTextFile class
- */
-#define wxUSE_TEXTFILE 0
-/*
- * Use log classes and logging functions
- */
-#define wxUSE_LOG 0
-/*
- * Use time and date classes
- */
-#define wxUSE_TIMEDATE 0
-/*
- * Use wave class
- */
-#define wxUSE_WAVE 0
-/*
- * Use config system
- */
-#define wxUSE_CONFIG 0
-/*
- * Use intl system
- */
-#define wxUSE_INTL 0
-/*
- * Use streams
- */
-#define wxUSE_STREAMS 0
-/*
- * Use class serialization
- */
-#define wxUSE_SERIAL 0
-/*
- * Use sockets
- */
-#define wxUSE_SOCKETS 0
-/*
- * Use standard C++ streams if 1. If 0, use wxWin
- * streams implementation.
- */
-#define wxUSE_STD_IOSTREAM  0
-/*
- * wxLibrary class
- */
-#define wxUSE_DYNLIB_CLASS 1
-
-/* ------------------------------------------------------------------------ */
-/* PS options                                                               */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use font metric files in GetTextExtent for wxPostScriptDC
- * Use consistent PostScript fonts for AFM and printing (!)
- */
-#define wxUSE_AFM_FOR_POSTSCRIPT 0
-#define wxUSE_NORMALIZED_PS_FONTS 0
-
-/* compatibility */
-#define WX_NORMALIZED_PS_FONTS wxUSE_NORMALIZED_PS_FONTS
-
-/*
- * Use PostScript device context
- */
-#define wxUSE_POSTSCRIPT 0
-
-/* ------------------------------------------------------------------------ */
-/* wxString options                                                         */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Compile wxString with wide character (Unicode) support?
- */
-#define wxUSE_UNICODE 0
-
-/*
- * Work around a bug in GNU libc 5.x wcstombs() implementation.
- *
- * Note that you must link your programs with libc.a if you enable this and you
- * have libc 5 (you should enable this for libc6 where wcsrtombs() is
- * thread-safe version of wcstombs()).
- */
-#define wxUSE_WCSRTOMBS 0
-
-/*
- * On some platforms overloading on size_t/int doesn't work, yet we'd like
- * to define both size_t and int version of wxString::operator[] because it
- * should really be size_t, but a lot of old, broken code uses int indices.
- */
-#define wxUSE_SIZE_T_STRING_OPERATOR 0
-
-/*
- * Use the new experimental implementation of wxString::Printf()?
- *
- * Warning: enabling this may cause internal compiler errors with gcc!
- */
-#define wxUSE_EXPERIMENTAL_PRINTF 0
-
-/* ------------------------------------------------------------------------ */
-/* misc options                                                             */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use Interprocess communication
- */
-#define wxUSE_IPC 0
-/*
- * Use wxGetResource & wxWriteResource (change .Xdefaults)
- */
-#define wxUSE_X_RESOURCES 0
-/*
- * Use clipboard
- */
-#define wxUSE_CLIPBOARD 0
-/*
- * Use tooltips
- */
-#define wxUSE_TOOLTIPS 0
-/*
- * Use dnd
- */
-#define wxUSE_DRAG_AND_DROP 0
-/*
- * Use spline
- */
-#define wxUSE_SPLINES 0
-/*
- * Use wxLibrary class
- */
-#define wxUSE_DYNLIB_CLASS 0
-
-/* ------------------------------------------------------------------------ */
-/* architecture options                                                     */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use the mdi architecture
- */
-#define wxUSE_MDI_ARCHITECTURE 0
-/*
- * Use the document/view architecture
- */
-#define wxUSE_DOC_VIEW_ARCHITECTURE 0
-/*
- * Use the print/preview architecture
- */
-#define wxUSE_PRINTING_ARCHITECTURE 0
-
-/* ------------------------------------------------------------------------ */
-/* Prolog and wxWindows' resource system options                            */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use Prolog IO
- */
-#define wxUSE_PROLOGIO 0
-/*
- * Use wxWindows resource loading (.wxr-files) (Needs wxUSE_PROLOGIO 1)
- */
-#define wxUSE_RESOURCES 0
-
-/* for compatibility */
-#define wxUSE_WX_RESOURCES wxUSE_RESOURCES
-
-/* ------------------------------------------------------------------------ */
-/* the rest                                                                 */
-/* ------------------------------------------------------------------------ */
-
-/*
- * Use wxWindows help facility (needs wxUSE_IPC 1)
- */
-#define wxUSE_HELP 0
-/*
- * Use iostream.h rather than iostream
- */
-#define wxUSE_IOSTREAMH 0
-/*
- * Use Apple Ieee-double converter
- */
-#define wxUSE_APPLE_IEEE 0
-/* 
- * Compatibility with 1.66 API.
- * Level 0: no backward compatibility, all new features
- * Level 1: wxDC, OnSize (etc.) compatibility, but
- * some new features such as event tables 
- */
-#define WXWIN_COMPATIBILITY 0
-/* 
- * Compatibility with 2.0 API. 
- */
-#define WXWIN_COMPATIBILITY_2 1
-/*
- * Enables debugging: memory tracing, assert, etc., contains debug level
- */
-#define WXDEBUG 0
-/*
- * Enables debugging version of wxObject::new and wxObject::delete (IF WXDEBUG)
- * WARNING: this code may not work with all architectures, especially
- * if alignment is an issue.
- */
-#define wxUSE_MEMORY_TRACING 0
-/*
- * Enable debugging version of global memory operators new and delete
- * Disable it, If this causes problems (e.g. link errors)
- */
-#define wxUSE_DEBUG_NEW_ALWAYS 0
-/*
- * VZ: What does this one do? (FIXME)
- */
-#define wxUSE_DEBUG_CONTEXT 0
-/*
- * In debug mode, causes new to be defined to
- * be WXDEBUG_NEW (see object.h). If this causes
- * problems (e.g. link errors), set this to 0.
- */
-#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
-/*
- * Matthews garbage collection (used for MrEd?)
- */
-#define WXGARBAGE_COLLECTION_ON 0
-/*
- * Use splines
- */
-#define wxUSE_SPLINES 0
-/*
- * wxUSE_DYNAMIC_CLASSES is TRUE for the Xt port
- */
-#define wxUSE_DYNAMIC_CLASSES 1
-
-/*
- * Support for metafiles
- */
-#define wxUSE_METAFILE 0
-
-/*
- * wxMiniFrame
- */
-#define wxUSE_MINIFRAME 0
-
-/*
- * Disable this if your compiler can't cope
- * with omission of prototype parameters.
- */
-#define REMOVE_UNUSED_ARG 1
-/*
- * The const keyword is being introduced more in wxWindows.
- * You can use this setting to maintain backward compatibility.
- * If 0:	will use const wherever possible.
- * If 1:	will use const only where necessary
- *              for precompiled headers to work.
- * If 2:	will be totally backward compatible, but precompiled
- *	headers may not work and program size will be larger.
- */
-#define CONST_COMPATIBILITY 0
-
-/* ------------------------------------------------------------------------ */
-/* System-specific stuff                                                    */
-/* ------------------------------------------------------------------------ */
-
-/* The type of 3rd argument to getsockname() - usually size_t or int */
-#undef SOCKLEN_T
-
-/* Define if you have dlopen() */
-#undef HAVE_DLOPEN
-
-/* Define if you have nanosleep() */
-#undef HAVE_NANOSLEEP
-
-/* Define if you have sched_yield */
-#undef HAVE_SCHED_YIELD
-
-/* Define if you have pthread_cancel */
-#undef HAVE_PTHREAD_CANCEL
-
-/* Define if you have all functions to set thread priority */
-#undef HAVE_THREAD_PRIORITY_FUNCTIONS
-
-/* Define if you can specify exit functions to a thread */
-#undef HAVE_THREAD_CLEANUP_FUNCTIONS
-
-/* Define if you have shl_load() */
-#undef HAVE_SHL_LOAD
-
-/* Define if you have vsnprintf() */
-#undef HAVE_VSNPRINTF
-
-/* Define if you have usleep() */
-#undef HAVE_USLEEP
-
-/* Define if you have wcslen function  */
-#undef HAVE_WCSLEN
-
-@BOTTOM@
-
-#endif /* __GTKSETUPH__ */

acinclude.m4

@@ -1,399 +0,0 @@
-dnl ---------------------------------------------------------------------------
-dnl
-dnl Purpose: Cursom macros for autoconf configure script.
-dnl Author:  Vadim Zeitlin
-dnl Created: 26.05.99
-dnl Version: $Id$
-dnl ---------------------------------------------------------------------------
-
-dnl ===========================================================================
-dnl GKT+ version test
-dnl ===========================================================================
-
-dnl ---------------------------------------------------------------------------
-dnl AM_PATH_GTK([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
-dnl Test for GTK, and define GTK_CFLAGS and GTK_LIBS. Uses variables
-dnl gtk_config_prefix and/or gtk_config_exec_prefix if defined.
-dnl ---------------------------------------------------------------------------
-dnl
-AC_DEFUN(AM_PATH_GTK,
-[
-  if test x$gtk_config_exec_prefix != x ; then
-     gtk_config_args="$gtk_config_args --exec-prefix=$gtk_config_exec_prefix"
-     if test x${GTK_CONFIG+set} != xset ; then
-        GTK_CONFIG=$gtk_config_exec_prefix/bin/gtk-config
-     fi
-  fi
-  if test x$gtk_config_prefix != x ; then
-     gtk_config_args="$gtk_config_args --prefix=$gtk_config_prefix"
-     if test x${GTK_CONFIG+set} != xset ; then
-        GTK_CONFIG=$gtk_config_prefix/bin/gtk-config
-     fi
-  fi
-
-  AC_PATH_PROG(GTK_CONFIG, gtk-config, no)
-  min_gtk_version=ifelse([$1], ,0.99.7,$1)
-  AC_MSG_CHECKING(for GTK - version >= $min_gtk_version)
-  no_gtk=""
-  if test "$GTK_CONFIG" != "no" ; then
-    GTK_CFLAGS=`$GTK_CONFIG --cflags`
-    GTK_LIBS=`$GTK_CONFIG --libs`
-    ac_save_CFLAGS="$CFLAGS"
-    ac_save_LIBS="$LIBS"
-    CFLAGS="$CFLAGS $GTK_CFLAGS"
-    LIBS="$LIBS $GTK_LIBS"
-dnl
-dnl Now check if the installed GTK is sufficiently new. (Also sanity
-dnl checks the results of gtk-config to some extent)
-dnl
-    AC_TRY_RUN([
-#include <gtk/gtk.h>
-#include <stdio.h>
-
-int
-main ()
-{
-  int major, minor, micro;
-
-  if (sscanf("$min_gtk_version", "%d.%d.%d", &major, &minor, &micro) != 3) {
-     printf("%s, bad version string\n", "$min_gtk_version");
-     exit(1);
-   }
-
-   if (gtk_minor_version == 1) return FALSE;
-
-   return !((gtk_major_version > major) ||
-	    ((gtk_major_version == major) && (gtk_minor_version > minor)) ||
-	    ((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro)));
-}
-],, no_gtk=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
-     CFLAGS="$ac_save_CFLAGS"
-     LIBS="$ac_save_LIBS"
-  else
-     no_gtk=yes
-  fi
-  if test "x$no_gtk" = x ; then
-     AC_MSG_RESULT(yes)
-     ifelse([$2], , :, [$2])
-  else
-     AC_MSG_RESULT(no)
-     GTK_CFLAGS=""
-     GTK_LIBS=""
-     ifelse([$3], , :, [$3])
-  fi
-  AC_SUBST(GTK_CFLAGS)
-  AC_SUBST(GTK_LIBS)
-])
-
-dnl ===========================================================================
-dnl macros to find the a file in the list of include/lib paths
-dnl ===========================================================================
-
-dnl ---------------------------------------------------------------------------
-dnl call WX_PATH_FIND_INCLUDES(search path, header name), sets ac_find_includes
-dnl to the full name of the file that was found or leaves it empty if not found
-dnl ---------------------------------------------------------------------------
-AC_DEFUN(WX_PATH_FIND_INCLUDES,
-[
-ac_find_includes=
-for ac_dir in $1;
-  do
-    if test -f "$ac_dir/$2"; then
-      ac_find_includes=$ac_dir
-      break
-    fi
-  done
-])
-
-dnl ---------------------------------------------------------------------------
-dnl call WX_PATH_FIND_LIBRARIES(search path, header name), sets ac_find_includes
-dnl to the full name of the file that was found or leaves it empty if not found
-dnl ---------------------------------------------------------------------------
-AC_DEFUN(WX_PATH_FIND_LIBRARIES,
-[
-ac_find_libraries=
-for ac_dir in $1;
-  do
-    for ac_extension in a so sl; do
-      if test -f "$ac_dir/lib$2.$ac_extension"; then
-        ac_find_libraries=$ac_dir
-        break 2
-      fi
-    done
-  done
-])
-
-dnl ---------------------------------------------------------------------------
-dnl Path to include, already defined
-dnl ---------------------------------------------------------------------------
-AC_DEFUN(WX_INCLUDE_PATH_EXIST,
-[
-  ac_path_to_include=$1
-  echo "$2" | grep "\-I$1" > /dev/null
-  result=$?
-  if test $result = 0; then
-    ac_path_to_include=""
-  else
-    ac_path_to_include="-I$1"
-  fi
-])
-
-dnl ---------------------------------------------------------------------------
-dnl Path to link, already defined
-dnl ---------------------------------------------------------------------------
-AC_DEFUN(WX_LINK_PATH_EXIST,
-[
-  echo "$2" | grep "\-L$1" > /dev/null
-  result=$?
-  if test $result = 0; then
-    ac_path_to_link=""
-  else
-    ac_path_to_link="-L$1"
-  fi
-])
-
-dnl ===========================================================================
-dnl C++ features test
-dnl ===========================================================================
-
-dnl ---------------------------------------------------------------------------
-dnl WX_CPP_NEW_HEADERS checks whether the compiler has "new" <iostream> header
-dnl or only the old <iostream.h> one - it may be generally assumed that if
-dnl <iostream> exists, the other "new" headers (without .h) exist too.
-dnl
-dnl call WX_CPP_NEW_HEADERS(actiof-if-true, action-if-false-or-cross-compiling)
-dnl ---------------------------------------------------------------------------
-
-AC_DEFUN(WX_CPP_NEW_HEADERS,
-[
-  if test "$cross_compiling" = "yes"; then
-    ifelse([$2], , :, [$2])
-  else
-    AC_LANG_SAVE
-    AC_LANG_CPLUSPLUS
-
-    AC_CHECK_HEADERS(iostream)
-
-    if test "x$HAVE_IOSTREAM" = x ; then
-      ifelse([$2], , :, [$2])
-    else
-      ifelse([$1], , :, [$1])
-    fi
-
-    AC_LANG_RESTORE
-  fi
-])
-
-dnl ---------------------------------------------------------------------------
-dnl WX_CPP_BOOL checks whether the C++ compiler has a built in bool type
-dnl
-dnl call WX_CPP_BOOL - will define HAVE_BOOL if the compiler supports bool
-dnl ---------------------------------------------------------------------------
-
-AC_DEFUN(WX_CPP_BOOL,
-[
-  AC_CACHE_CHECK([if C++ compiler supports bool], wx_cv_cpp_bool,
-  [
-    AC_LANG_SAVE
-    AC_LANG_CPLUSPLUS
-
-    AC_TRY_RUN([
-        int main()
-        {
-            bool b = true;
-
-            return 0;
-        }
-      ],
-      [
-        AC_DEFINE(HAVE_BOOL)
-        wx_cv_cpp_bool=yes
-      ],
-      wx_cv_cpp_bool=no,
-      wx_cv_cpp_bool=no
-    )
-
-    AC_LANG_RESTORE
-  ])
-
-  if test "$wx_cv_cpp_bool" = "yes"; then
-    AC_DEFINE(HAVE_BOOL)
-  fi
-])
-
-dnl ---------------------------------------------------------------------------
-dnl WX_CPP_SIZE_T_IS_NOT_INT checks whether size_t and int are different types,
-dnl i.e. whether we may overload operator[] on its argument type
-dnl ---------------------------------------------------------------------------
-
-AC_DEFUN(WX_CPP_SIZE_T_IS_NOT_INT,
-[
-  AC_CACHE_CHECK([if size_t and int are different types], wx_cv_cpp_sizet_not_int,
-  [
-    AC_LANG_SAVE
-    AC_LANG_CPLUSPLUS
-
-    AC_TRY_RUN([
-        #include <stdlib.h>
-
-        class S
-        {
-        public:
-          S(char *s) { m_s = s; }
-
-          char operator[](size_t n) const { return m_s[n]; }
-          char operator[](int n) const { return m_s[n]; }
-
-        private:
-          char *m_s;
-        };
-
-        int main()
-        {
-            S s("dummy");
-            size_t n1 = 2;
-            int n2 = 3;
-
-            return s[n1] == s[n2];
-        }
-      ],
-      AC_DEFINE(wxUSE_SIZE_T_STRING_OPERATOR) wx_cv_cpp_sizet_not_int=yes,
-      wx_cv_cpp_sizet_not_int=no,
-      wx_cv_cpp_sizet_not_int=no
-    )
-
-    AC_LANG_RESTORE
-  ])
-])
-
-dnl ---------------------------------------------------------------------------
-dnl a slightly better AC_C_BIGENDIAN macro which allows cross-compiling
-dnl ---------------------------------------------------------------------------
-
-AC_DEFUN(WX_C_BIGENDIAN,
-[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
-[ac_cv_c_bigendian=unknown
-# See if sys/param.h defines the BYTE_ORDER macro.
-AC_TRY_COMPILE([#include <sys/types.h>
-#include <sys/param.h>], [
-#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
- bogus endian macros
-#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
-AC_TRY_COMPILE([#include <sys/types.h>
-#include <sys/param.h>], [
-#if BYTE_ORDER != BIG_ENDIAN
- not big endian
-#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
-if test $ac_cv_c_bigendian = unknown; then
-AC_TRY_RUN([main () {
-  /* Are we little or big endian?  From Harbison&Steele.  */
-  union
-  {
-    long l;
-    char c[sizeof (long)];
-  } u;
-  u.l = 1;
-  exit (u.c[sizeof (long) - 1] == 1);
-}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes, ac_cv_c_bigendian=unknown)
-fi])
-if test $ac_cv_c_bigendian = unknown; then
-  AC_MSG_WARN([Assuming little-endian target machine - this may be overriden by adding the line "ac_cv_c_bigendian=${ac_cv_c_bigendian='yes'}" to config.cache file])
-fi
-if test $ac_cv_c_bigendian = yes; then
-  AC_DEFINE(WORDS_BIGENDIAN)
-fi
-])
-
-dnl ---------------------------------------------------------------------------
-dnl override AC_ARG_ENABLE/WITH to cache the results in .cache file
-dnl ---------------------------------------------------------------------------
-
-AC_DEFUN(WX_ARG_CACHE_INIT,
-        [
-          wx_arg_cache_file="configarg.cache"
-          echo "loading argument cache $wx_arg_cache_file"
-          rm -f ${wx_arg_cache_file}.tmp
-          touch ${wx_arg_cache_file}.tmp
-          touch ${wx_arg_cache_file}
-        ])
-
-AC_DEFUN(WX_ARG_CACHE_FLUSH,
-        [
-          echo "saving argument cache $wx_arg_cache_file"
-          mv ${wx_arg_cache_file}.tmp ${wx_arg_cache_file}
-        ])
-
-dnl this macro checks for a command line argument and caches the result
-dnl usage: WX_ARG_WITH(option, helpmessage, variable-name)
-AC_DEFUN(WX_ARG_WITH,
-        [
-          AC_MSG_CHECKING("for --with-$1")
-          no_cache=0
-          AC_ARG_WITH($1, $2,
-                      [
-                        if test "$withval" = yes; then
-                          ac_cv_use_$1='$3=yes'
-                        else
-                          ac_cv_use_$1='$3=no'
-                        fi
-                      ],
-                      [
-                        LINE=`grep "$3" ${wx_arg_cache_file}`
-                        if test "x$LINE" != x ; then
-                          eval "DEFAULT_$LINE"
-                        else
-                          no_cache=1
-                        fi
-
-                        ac_cv_use_$1='$3='$DEFAULT_$3
-                      ])
-
-          eval "$ac_cv_use_$1"
-          if test "$no_cache" != 1; then
-            echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
-          fi
-
-          if test "$$3" = yes; then
-            AC_MSG_RESULT(yes)
-          else
-            AC_MSG_RESULT(no)
-          fi
-        ])
-
-dnl like WX_ARG_WITH but uses AC_ARG_ENABLE instead of AC_ARG_WITH
-dnl usage: WX_ARG_ENABLE(option, helpmessage, variable-name)
-AC_DEFUN(WX_ARG_ENABLE,
-        [
-          AC_MSG_CHECKING("for --enable-$1")
-          no_cache=0
-          AC_ARG_ENABLE($1, $2,
-                        [
-                          if test "$enableval" = yes; then
-                            ac_cv_use_$1='$3=yes'
-                          else
-                            ac_cv_use_$1='$3=no'
-                          fi
-                        ],
-                        [
-                          LINE=`grep "$3" ${wx_arg_cache_file}`
-                          if test "x$LINE" != x ; then
-                            eval "DEFAULT_$LINE"
-                          else
-                            no_cache=1
-                          fi
-
-                          ac_cv_use_$1='$3='$DEFAULT_$3
-                        ])
-
-          eval "$ac_cv_use_$1"
-          if test "$no_cache" != 1; then
-            echo $ac_cv_use_$1 >> ${wx_arg_cache_file}.tmp
-          fi
-
-          if test "$$3" = yes; then
-            AC_MSG_RESULT(yes)
-          else
-            AC_MSG_RESULT(no)
-          fi
-        ])
-

autogen.sh

@@ -1,5 +1,2 @@
 #!/bin/sh
-aclocal -I .
-autoheader
-automake --foreign --verbose
 autoconf

demos/Makefile.in

@@ -0,0 +1,11 @@
+#
+# Makefile : Builds wxWindows demos for Unix.
+#
+
+DEMOS_SUBDIRS=bombs forty fractal life poem
+
+all:
+	@for d in $(DEMOS_SUBDIRS); do (cd $$d && make); done
+
+clean:
+	@for d in $(DEMOS_SUBDIRS); do (cd $$d && make clean); done

demos/bombs/Makefile.in

@@ -0,0 +1,21 @@
+#
+# File:		Makefile.in
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998 Julian Smart
+#
+# "%W% %G%"
+#
+# Makefile for bombs example (UNIX).
+
+top_srcdir = @top_srcdir@
+top_builddir = ../..
+program_dir = demos/bombs
+
+PROGRAM=bombs
+
+OBJECTS = bombs.o bombs1.o game.o
+
+include ../../src/makeprog.env
+

demos/bombs/bombs1.cpp

@@ -167,8 +167,8 @@ void BombsCanvasClass::Refresh(int xc1, int yc1, int xc2, int yc2)
 // Called when the canvas receives a mouse event.
 void BombsCanvasClass::OnEvent(wxMouseEvent& event)
 {
-  long fx, fy;
-  event.Position(&fx, &fy);
+  wxCoord fx, fy;
+  event.GetPosition(&fx, &fy);
   int x = fx/(x_cell*X_UNIT);
   int y = fy/(y_cell*Y_UNIT);
   if (x<field_width && y<field_height)

demos/bombs/descrip.mms

@@ -0,0 +1,32 @@
+#*****************************************************************************
+#                                                                            *
+# Make file for VMS                                                          *
+# Author : J.Jansen (joukj@hrem.stm.tudelft.nl)                              *
+# Date : 10 November 1999                                                     *
+#                                                                            *
+#*****************************************************************************
+.first
+	define wx [--.include.wx]
+
+.ifdef __WXMOTIF__
+CXX_DEFINE = /define=(__WXMOTIF__=1)
+.else
+CXX_DEFINE =
+.endif
+
+.suffixes : .cpp
+
+.cpp.obj :
+	cxx $(CXXFLAGS)$(CXX_DEFINE) $(MMS$TARGET_NAME).cpp
+
+all :
+	$(MMS)$(MMSQUALIFIERS) game.exe
+
+game.exe : game.obj bombs1.obj bombs.obj
+.ifdef __WXMOTIF__
+	cxxlink game,bombs1,bombs,[--.lib]vms/opt
+.endif
+
+game.obj : game.cpp
+bombs1.obj : bombs1.cpp
+bombs.obj : bombs.cpp

demos/bombs/makefile.dos

@@ -0,0 +1,17 @@
+#
+# File:		makefile.dos
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+#
+# Makefile : Builds 16-bit sample, VC++ 1.5
+# Use FINAL=1 argument to nmake to build final version with no debugging
+# info
+
+WXDIR = $(WXWIN)
+
+TARGET=bombs
+OBJECTS = $(TARGET).obj bombs1.obj game.obj
+
+!include $(WXDIR)\src\makeprog.msc
+

demos/bombs/makefile.unx

@@ -0,0 +1,35 @@
+#
+# File:		Makefile for samples
+# Author:	Robert Roebling
+# Created:	1999
+# Updated:	
+# Copyright:	(c) 1998 Robert Roebling
+#
+# This makefile requires a Unix version of wxWindows
+# to be installed on your system. This is most often
+# done typing "make install" when using the complete
+# sources of wxWindows or by installing the two
+# RPM packages wxGTK.XXX.rpm and wxGTK-devel.XXX.rpm
+# under Linux.
+#
+
+CC = gcc
+
+PROGRAM = bombs
+
+OBJECTS = $(PROGRAM).o game.o bombs1.o
+
+# implementation
+
+.SUFFIXES:	.o .cpp
+
+.cpp.o :
+	$(CC) -c `wx-config --cflags` -o $@ $<
+
+all:    $(PROGRAM)
+
+$(PROGRAM):	$(OBJECTS)
+	$(CC) -o $(PROGRAM) $(OBJECTS) `wx-config --libs`
+
+clean: 
+	rm -f *.o $(PROGRAM)

demos/forty/.cvsignore

@@ -0,0 +1 @@
+

demos/forty/Makefile.in

@@ -0,0 +1,21 @@
+#
+# File:		Makefile.in
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998 Julian Smart
+#
+# "%W% %G%"
+#
+# Makefile for forty example (UNIX).
+
+top_srcdir = @top_srcdir@
+top_builddir = ../..
+program_dir = demos/forty
+
+PROGRAM=forty
+
+OBJECTS=$(PROGRAM).o canvas.o card.o game.o pile.o playerdg.o scoredg.o scorefil.o
+
+include ../../src/makeprog.env
+

demos/forty/card.cpp

@@ -41,7 +41,7 @@
 #include "forty.h"
 #include "card.h"
 
-#if defined(__WXGTK__) || defined(__WXMOTIF__)
+#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__)
 #include "pictures.xpm"
 #include "symbols.xbm"
 #endif

demos/forty/forty.cpp

@@ -131,6 +131,10 @@ const wxColour& FortyApp::TextColour()
 FortyFrame::FortyFrame(wxFrame* frame, char* title, int x, int y, int w, int h):
 	wxFrame(frame, -1, title, wxPoint(x, y), wxSize(w, h))
 {
+#ifdef __WXMAC__
+	// we need this in order to allow the about menu relocation, since ABOUT is not the default id of the about menu 
+	wxApp::s_macAboutMenuItemId = ABOUT ;
+#endif
 	// set the icon
 #ifdef __WXMSW__
 	SetIcon(wxIcon("CardsIcon"));

demos/forty/game.cpp

@@ -0,0 +1,946 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        game.cpp
+// Purpose:     Forty Thieves patience game
+// Author:      Chris Breeze
+// Modified by:
+// Created:     21/07/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1993-1998 Chris Breeze
+// Licence:   	wxWindows licence
+//---------------------------------------------------------------------------
+// Last modified: 22nd July 1998 - ported to wxWindows 2.0
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#pragma interface
+#endif
+
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include "forty.h"
+#include "game.h"
+
+Game::Game(int wins, int games, int score) :
+	m_inPlay(FALSE),
+	m_moveIndex(0),
+	m_redoIndex(0),
+	m_bmap(0),
+	m_bmapCard(0)
+{
+    int i;
+
+    m_pack = new Pack(2, 2 + 4 * (CardHeight + 2));
+    srand(time(0));
+
+    for (i = 0; i < 5; i++) m_pack->Shuffle();
+
+    m_discard = new Discard(2, 2 + 5 * (CardHeight + 2));
+
+    for (i = 0; i < 8; i++)
+    {
+		m_foundations[i] = new Foundation(2 + (i / 4) * (CardWidth + 2),
+					2 + (i % 4) * (CardHeight + 2));
+    }
+
+    for (i = 0; i < 10; i++)
+    {
+    	m_bases[i] = new Base(8 + (i + 2) * (CardWidth + 2), 2);
+    }
+    Deal();
+    m_srcPile = 0;
+    m_liftedCard = 0;
+
+	// copy the input parameters for future reference
+    m_numWins = wins;
+    m_numGames = games;
+    m_totalScore = score;
+    m_currentScore = 0;
+}
+
+
+// Make sure we delete all objects created by the game object
+Game::~Game()
+{
+    int i;
+
+    delete m_pack;
+    delete m_discard;
+    for (i = 0; i < 8; i++)
+    {
+		delete m_foundations[i];
+    }
+    for (i = 0; i < 10; i++)
+    {
+		delete m_bases[i];
+    }
+	delete m_bmap;
+	delete m_bmapCard;
+}
+
+/*
+Set the score for a new player.
+NB: call Deal() first if the new player is to start
+a new game
+*/
+void Game::NewPlayer(int wins, int games, int score)
+{
+    m_numWins = wins;
+    m_numGames = games;
+    m_totalScore = score;
+    m_currentScore = 0;
+}
+
+// Undo the last move
+void Game::Undo(wxDC& dc)
+{
+    if (m_moveIndex > 0)
+    {
+		m_moveIndex--;
+		Card* card = m_moves[m_moveIndex].dest->RemoveTopCard(dc);
+		m_moves[m_moveIndex].src->AddCard(dc, card);
+		DisplayScore(dc);
+    }
+}
+
+// Redo the last move
+void Game::Redo(wxDC& dc)
+{
+    if (m_moveIndex < m_redoIndex)
+    {
+		Card* card = m_moves[m_moveIndex].src->RemoveTopCard(dc);
+		if (m_moves[m_moveIndex].src == m_pack)
+		{
+			m_pack->Redraw(dc);
+			card->TurnCard(faceup);
+		}
+		m_moves[m_moveIndex].dest->AddCard(dc, card);
+		DisplayScore(dc);
+		m_moveIndex++;
+    }
+}
+
+void Game::DoMove(wxDC& dc, Pile* src, Pile* dest)
+{
+    if (m_moveIndex < MaxMoves)
+    {
+		if (src == dest)
+		{
+			wxMessageBox("Game::DoMove() src == dest", "Debug message",
+				   wxOK | wxICON_EXCLAMATION);
+		}
+		m_moves[m_moveIndex].src = src;
+		m_moves[m_moveIndex].dest = dest;
+		m_moveIndex++;
+
+		// when we do a move any moves in redo buffer are discarded
+		m_redoIndex = m_moveIndex;
+    }
+    else
+    {
+		wxMessageBox("Game::DoMove() Undo buffer full", "Debug message",
+			   wxOK | wxICON_EXCLAMATION);
+    }
+
+    if (!m_inPlay)
+	{
+		m_inPlay = TRUE;
+		m_numGames++;
+	}
+    DisplayScore(dc);
+}
+
+
+void Game::DisplayScore(wxDC& dc)
+{
+    wxColour bgColour = FortyApp::BackgroundColour();
+	wxPen* pen = wxThePenList->FindOrCreatePen(bgColour, 1, wxSOLID);
+    dc.SetTextBackground(bgColour);
+    dc.SetTextForeground(FortyApp::TextColour());
+	dc.SetBrush(FortyApp::BackgroundBrush());
+	dc.SetPen(* pen);
+
+	// count the number of cards in foundations
+    m_currentScore = 0;
+    for (int i = 0; i < 8; i++)
+    {
+    	m_currentScore += m_foundations[i]->GetNumCards();
+    }
+
+    int x, y;
+    m_pack->GetTopCardPos(x, y);
+    x += 12 * CardWidth - 105;
+
+	int w, h;
+	{
+		long width, height;
+		dc.GetTextExtent("Average score:m_x", &width, &height);
+		w = width;
+		h = height;
+	}
+	dc.DrawRectangle(x + w, y, 20, 4 * h);
+
+    char str[80];
+    sprintf(str, "%d", m_currentScore);
+    dc.DrawText("Score:", x, y);
+    dc.DrawText(str, x + w, y);
+    y += h;
+
+    sprintf(str, "%d", m_numGames);
+    dc.DrawText("Games played:", x, y);
+    dc.DrawText(str, x + w, y);
+    y += h;
+
+    sprintf(str, "%d", m_numWins);
+    dc.DrawText("Games won:", x, y);
+    dc.DrawText(str, x + w, y);
+    y += h;
+
+    int average = 0;
+	if (m_numGames > 0)
+	{
+		average = (2 * (m_currentScore + m_totalScore) + m_numGames ) / (2 * m_numGames);
+	}
+    sprintf(str, "%d", average);
+    dc.DrawText("Average score:", x, y);
+    dc.DrawText(str, x + w, y);
+}
+
+
+// Shuffle the m_pack and deal the cards
+void Game::Deal()
+{
+    int i, j;
+    Card* card;
+
+	// Reset all the piles, the undo buffer and shuffle the m_pack
+    m_moveIndex = 0;
+    m_pack->ResetPile();
+    for (i = 0; i < 5; i++)
+	{
+		m_pack->Shuffle();
+	}
+    m_discard->ResetPile();
+    for (i = 0; i < 10; i++)
+	{
+		m_bases[i]->ResetPile();
+	}
+    for (i = 0; i <  8; i++)
+	{
+		m_foundations[i]->ResetPile();
+	}
+
+    	// Deal the initial 40 cards onto the bases
+    for (i = 0; i < 10; i++)
+    {
+		for (j = 1; j <= 4; j++)
+		{
+			card = m_pack->RemoveTopCard();
+			card->TurnCard(faceup);
+			m_bases[i]->AddCard(card);
+		}
+    }
+
+    if (m_inPlay)
+	{
+		// player has started the game and then redealt
+		// and so we must add the score for this game to the total score
+		m_totalScore += m_currentScore;
+	}
+    m_currentScore = 0;
+    m_inPlay = FALSE;
+}
+
+
+// Redraw the m_pack, discard pile, the bases and the foundations
+void Game::Redraw(wxDC& dc)
+{
+	int i;
+	m_pack->Redraw(dc);
+	m_discard->Redraw(dc);
+	for (i = 0; i < 8; i++)
+	{
+		m_foundations[i]->Redraw(dc);
+	}
+	for (i = 0; i < 10; i++)
+	{
+		m_bases[i]->Redraw(dc);
+	}
+	DisplayScore(dc);
+
+	if (m_bmap == 0)
+	{
+		m_bmap = new wxBitmap(CardWidth, CardHeight);
+		m_bmapCard = new wxBitmap(CardWidth, CardHeight);
+
+		// Initialise the card bitmap to the background colour
+		wxMemoryDC memoryDC;
+		memoryDC.SelectObject(*m_bmapCard);
+        memoryDC.SetPen( *wxTRANSPARENT_PEN );
+		memoryDC.SetBrush(FortyApp::BackgroundBrush());
+		memoryDC.DrawRectangle(0, 0, CardWidth, CardHeight);
+		memoryDC.SelectObject(*m_bmap);
+		memoryDC.DrawRectangle(0, 0, CardWidth, CardHeight);
+		memoryDC.SelectObject(wxNullBitmap);
+	}
+}
+
+
+// Test to see if the point (x, y) is over the top card of one of the piles
+// Returns pointer to the pile, or 0 if (x, y) is not over a pile
+// or the pile is empty
+Pile* Game::WhichPile(int x, int y)
+{
+	if (m_pack->GetCard(x, y) &&
+		m_pack->GetCard(x, y) == m_pack->GetTopCard())
+	{
+		return m_pack;
+	}
+
+	if (m_discard->GetCard(x, y) &&
+		m_discard->GetCard(x, y) == m_discard->GetTopCard())
+	{
+		return m_discard;
+	}
+
+	int i;
+	for (i = 0; i < 8; i++)
+	{
+		if (m_foundations[i]->GetCard(x, y) &&
+			m_foundations[i]->GetCard(x, y) == m_foundations[i]->GetTopCard())
+		{
+			return m_foundations[i];
+		}
+	}
+
+	for (i = 0; i < 10; i++)
+	{
+		if (m_bases[i]->GetCard(x, y) &&
+			m_bases[i]->GetCard(x, y) == m_bases[i]->GetTopCard())
+		{
+			return m_bases[i];
+		}
+	}
+	return 0;
+}
+
+
+// Left button is pressed - if cursor is over the m_pack then deal a card
+// otherwise if it is over a card pick it up ready to be dragged - see MouseMove()
+bool Game::LButtonDown(wxDC& dc, int x, int y)
+{
+    m_srcPile = WhichPile(x, y);
+    if (m_srcPile == m_pack)
+    {
+		Card* card = m_pack->RemoveTopCard();
+		if (card)
+		{
+			m_pack->Redraw(dc);
+			card->TurnCard(faceup);
+			m_discard->AddCard(dc, card);
+			DoMove(dc, m_pack, m_discard);
+		}
+        m_srcPile = 0;
+    }
+    else if (m_srcPile)
+    {
+		m_srcPile->GetTopCardPos(m_xPos, m_yPos);
+		m_xOffset = m_xPos - x;
+		m_yOffset = m_yPos - y;
+
+			// Copy the area under the card
+			// Initialise the card bitmap to the background colour
+		{
+			wxMemoryDC memoryDC;
+			memoryDC.SelectObject(*m_bmap);
+			m_liftedCard = m_srcPile->RemoveTopCard(memoryDC, m_xPos, m_yPos);
+		}
+
+			// Draw the card in card bitmap ready for blitting onto
+			// the screen
+		{
+			wxMemoryDC memoryDC;
+			memoryDC.SelectObject(*m_bmapCard);
+			m_liftedCard->Draw(memoryDC, 0, 0);
+		}
+    }
+    return m_srcPile != 0;
+}
+
+// Called when the left button is double clicked
+// If a card is under the pointer and it can move elsewhere then move it.
+// Move onto a foundation as first choice, a populated base as second and
+// an empty base as third choice.
+// NB Cards in the m_pack cannot be moved in this way - they aren't in play
+// yet
+void Game::LButtonDblClk(wxDC& dc, int x, int y)
+{
+    Pile* pile = WhichPile(x, y);
+    if (!pile) return;
+
+    	// Double click on m_pack is the same as left button down
+    if (pile == m_pack)
+    {
+		LButtonDown(dc, x, y);
+    }
+    else
+    {
+		Card* card = pile->GetTopCard();
+
+		if (card)
+		{
+			int i;
+
+			// if the card is an ace then try to place it next
+			// to an ace of the same suit
+			if (card->GetPipValue() == 1)
+			{
+				for(i = 0; i < 4; i++)
+				{
+					Card* m_topCard = m_foundations[i]->GetTopCard();
+					if ( m_topCard )
+                    {
+						if (m_topCard->GetSuit() == card->GetSuit() &&
+                            m_foundations[i + 4] != pile &&
+							m_foundations[i + 4]->GetTopCard() == 0)
+						{
+							pile->RemoveTopCard(dc);
+							m_foundations[i + 4]->AddCard(dc, card);
+							DoMove(dc, pile, m_foundations[i + 4]);
+							return;
+						}
+                    }
+				}
+			}
+
+			// try to place the card on a foundation
+			for(i = 0; i < 8; i++)
+			{
+				if (m_foundations[i]->AcceptCard(card) && m_foundations[i] != pile)
+				{
+					pile->RemoveTopCard(dc);
+					m_foundations[i]->AddCard(dc, card);
+					DoMove(dc, pile, m_foundations[i]);
+					return;
+				}
+            }
+			// try to place the card on a populated base
+			for(i = 0; i < 10; i++)
+			{
+				if (m_bases[i]->AcceptCard(card) &&
+					m_bases[i] != pile &&
+					m_bases[i]->GetTopCard())
+				{
+					pile->RemoveTopCard(dc);
+					m_bases[i]->AddCard(dc, card);
+					DoMove(dc, pile, m_bases[i]);
+					return;
+				}
+            }
+			// try to place the card on any base
+			for(i = 0; i < 10; i++)
+			{
+				if (m_bases[i]->AcceptCard(card) && m_bases[i] != pile)
+				{
+					pile->RemoveTopCard(dc);
+					m_bases[i]->AddCard(dc, card);
+					DoMove(dc, pile, m_bases[i]);
+					return;
+				}
+            }
+		}
+    }
+}
+
+
+// Test to see whether the game has been won:
+// i.e. m_pack, discard and bases are empty
+bool Game::HaveYouWon()
+{
+    if (m_pack->GetTopCard()) return FALSE;
+    if (m_discard->GetTopCard()) return FALSE;
+    for(int i = 0; i < 10; i++)
+    {
+    	if (m_bases[i]->GetTopCard()) return FALSE;
+    }
+    m_numWins++;
+    m_totalScore += m_currentScore;
+    m_currentScore = 0;
+    return TRUE;
+}
+
+
+// See whether the card under the cursor can be moved somewhere else
+// Returns TRUE if it can be moved, FALSE otherwise
+bool Game::CanYouGo(int x, int y)
+{
+    Pile* pile = WhichPile(x, y);
+    if (pile && pile != m_pack)
+    {
+	Card* card = pile->GetTopCard();
+
+	if (card)
+	{
+	    int i;
+	    for(i = 0; i < 8; i++)
+	    {
+	    	if (m_foundations[i]->AcceptCard(card) && m_foundations[i] != pile)
+		{
+                    return TRUE;
+		}
+            }
+	    for(i = 0; i < 10; i++)
+	    {
+		if (m_bases[i]->GetTopCard() &&
+		    m_bases[i]->AcceptCard(card) &&
+		    m_bases[i] != pile)
+		{
+		    return TRUE;
+		}
+            }
+	}
+    }
+    return FALSE;
+}
+
+
+// Called when the left button is released after dragging a card
+// Scan the piles to see if this card overlaps a pile and can be added
+// to the pile. If the card overlaps more than one pile on which it can be placed
+// then put it on the nearest pile.
+void Game::LButtonUp(wxDC& dc, int x, int y)
+{
+    if (m_srcPile)
+    {
+        	// work out the position of the dragged card
+		x += m_xOffset;
+        y += m_yOffset;
+
+		Pile* nearestPile = 0;
+		int distance = (CardHeight + CardWidth) * (CardHeight + CardWidth);
+
+        	// find the nearest pile which will accept the card
+		int i;
+		for (i = 0; i < 8; i++)
+		{
+			if (DropCard(x, y, m_foundations[i], m_liftedCard))
+			{
+				if (m_foundations[i]->CalcDistance(x, y) < distance)
+				{
+					nearestPile = m_foundations[i];
+                    distance = nearestPile->CalcDistance(x, y);
+                }
+            }
+		}
+		for (i = 0; i < 10; i++)
+		{
+			if (DropCard(x, y, m_bases[i], m_liftedCard))
+			{
+				if (m_bases[i]->CalcDistance(x, y) < distance)
+                {
+					nearestPile = m_bases[i];
+                    distance = nearestPile->CalcDistance(x, y);
+                }
+            }
+		}
+
+		// Restore the area under the card
+		wxMemoryDC memoryDC;
+		memoryDC.SelectObject(*m_bmap);
+		dc.Blit(m_xPos, m_yPos, CardWidth, CardHeight,
+			   &memoryDC, 0, 0, wxCOPY);
+
+        	// Draw the card in its new position
+		if (nearestPile)
+		{
+			// Add to new pile
+			nearestPile->AddCard(dc, m_liftedCard);
+			if (nearestPile != m_srcPile)
+			{
+				DoMove(dc, m_srcPile, nearestPile);
+			}
+		}
+        else
+        {
+			// Return card to src pile
+			m_srcPile->AddCard(dc, m_liftedCard);
+		}
+		m_srcPile = 0;
+		m_liftedCard = 0;
+    }
+}
+
+
+
+
+bool Game::DropCard(int x, int y, Pile* pile, Card* card)
+{
+    bool retval = FALSE;
+    if (pile->Overlap(x, y))
+    {
+	if (pile->AcceptCard(card))
+	{
+	    retval = TRUE;
+        }
+    }
+    return retval;
+}
+
+
+void Game::MouseMove(wxDC& dc, int mx, int my)
+{
+    if (m_liftedCard)
+    {
+		wxMemoryDC memoryDC;
+		memoryDC.SelectObject(*m_bmap);
+
+		int dx = mx + m_xOffset - m_xPos;
+		int dy = my + m_yOffset - m_yPos;
+
+		if (abs(dx) >= CardWidth || abs(dy) >= CardHeight)
+        {
+			// Restore the area under the card
+			dc.Blit(m_xPos, m_yPos, CardWidth, CardHeight,
+			   &memoryDC, 0, 0, wxCOPY);
+
+			// Copy the area under the card in the new position
+			memoryDC.Blit(0, 0, CardWidth, CardHeight,
+			   &dc, m_xPos + dx, m_yPos + dy, wxCOPY);
+		}
+		else if (dx >= 0)
+		{
+			// dx >= 0
+			dc.Blit(m_xPos, m_yPos, dx, CardHeight, &memoryDC, 0, 0, wxCOPY);
+			if (dy >= 0)
+			{
+					// dy >= 0
+				dc.Blit(m_xPos + dx, m_yPos, CardWidth - dx, dy, &memoryDC, dx, 0, wxCOPY);
+				memoryDC.Blit(0, 0, CardWidth - dx, CardHeight - dy,
+					   &memoryDC, dx, dy, wxCOPY);
+				memoryDC.Blit(0, CardHeight - dy, CardWidth - dx, dy,
+					   &dc, m_xPos + dx, m_yPos + CardHeight, wxCOPY);
+			}
+			else
+			{
+                		// dy < 0
+				dc.Blit(m_xPos + dx, m_yPos + dy + CardHeight, CardWidth - dx, -dy,
+					   &memoryDC, dx, CardHeight + dy, wxCOPY);
+				memoryDC.Blit(0, -dy, CardWidth - dx, CardHeight + dy,
+					   &memoryDC, dx, 0, wxCOPY);
+				memoryDC.Blit(0, 0, CardWidth - dx, -dy,
+					   &dc, m_xPos + dx, m_yPos + dy, wxCOPY);
+			}
+			memoryDC.Blit(CardWidth - dx, 0, dx, CardHeight,
+	    		   &dc, m_xPos + CardWidth, m_yPos + dy, wxCOPY);
+		}
+		else
+		{
+			// dx < 0
+			dc.Blit(m_xPos + CardWidth + dx, m_yPos, -dx, CardHeight,
+	    		   &memoryDC, CardWidth + dx, 0, wxCOPY);
+			if (dy >= 0)
+			{
+				dc.Blit(m_xPos, m_yPos, CardWidth + dx, dy, &memoryDC, 0, 0, wxCOPY);
+				memoryDC.Blit(-dx, 0, CardWidth + dx, CardHeight - dy,
+					   &memoryDC, 0, dy, wxCOPY);
+				memoryDC.Blit(-dx, CardHeight - dy, CardWidth + dx, dy,
+					   &dc, m_xPos, m_yPos + CardHeight, wxCOPY);
+			}
+			else
+			{
+                			// dy < 0
+				dc.Blit(m_xPos, m_yPos + CardHeight + dy, CardWidth + dx, -dy,
+					   &memoryDC, 0, CardHeight + dy, wxCOPY);
+				memoryDC.Blit(-dx, -dy, CardWidth + dx, CardHeight + dy,
+					   &memoryDC, 0, 0, wxCOPY);
+				memoryDC.Blit(-dx, 0, CardWidth + dx, -dy,
+					   &dc, m_xPos, m_yPos + dy, wxCOPY);
+			}
+			memoryDC.Blit(0, 0, -dx, CardHeight,
+	    		   &dc, m_xPos + dx, m_yPos + dy, wxCOPY);
+		}
+		m_xPos += dx;
+		m_yPos += dy;
+
+			// draw the card in its new position
+		memoryDC.SelectObject(*m_bmapCard);
+		dc.Blit(m_xPos, m_yPos, CardWidth, CardHeight,
+			   &memoryDC, 0, 0, wxCOPY);
+    }
+}
+
+
+
+//----------------------------------------------//
+// The Pack class: holds the two decks of cards //
+//----------------------------------------------//
+Pack::Pack(int x, int y) : Pile(x, y, 0, 0)
+{
+    for (m_topCard = 0; m_topCard < NumCards; m_topCard++)
+    {
+    	m_cards[m_topCard] = new Card(1 + m_topCard / 2, facedown);
+    }
+    m_topCard = NumCards - 1;
+}
+
+
+void Pack::Shuffle()
+{
+    Card* temp[NumCards];
+    int i;
+
+	// Don't try to shuffle an empty m_pack!
+    if (m_topCard < 0) return;
+
+	// Copy the cards into a temporary array. Start by clearing
+	// the array and then copy the card into a random position.
+        // If the position is occupied then find the next lower position.
+    for (i = 0; i <= m_topCard; i++)
+    {
+		temp[i] = 0;
+    }
+    for (i = 0; i <= m_topCard; i++)
+    {
+	    int pos = rand() % (m_topCard + 1);
+	    while (temp[pos])
+	    {
+	        pos--;
+	        if (pos < 0) pos = m_topCard;
+	    }
+	    m_cards[i]->TurnCard(facedown);
+	    temp[pos] = m_cards[i];
+        m_cards[i] = 0;
+    }
+
+	// Copy each card back into the m_pack in a random
+	// position. If position is occupied then find nearest
+        // unoccupied position after the random position.
+    for (i = 0; i <= m_topCard; i++)
+    {
+	    int pos = rand() % (m_topCard + 1);
+	    while (m_cards[pos])
+	    {
+	        pos++;
+            if (pos > m_topCard) pos = 0;
+	    }
+        m_cards[pos] = temp[i];
+    }
+}
+
+void Pack::Redraw(wxDC& dc)
+{
+    Pile::Redraw(dc);
+
+    char str[10];
+    sprintf(str, "%d  ", m_topCard + 1);
+
+    dc.SetBackgroundMode( wxSOLID );
+	dc.SetTextBackground(FortyApp::BackgroundColour());
+	dc.SetTextForeground(FortyApp::TextColour());
+    dc.DrawText(str, m_x + CardWidth + 5, m_y + CardHeight / 2);
+
+}
+
+void Pack::AddCard(Card* card)
+{
+    if (card == m_cards[m_topCard + 1])
+    {
+		m_topCard++;
+    }
+    else
+    {
+		wxMessageBox("Pack::AddCard() Undo error", "Forty Thieves: Warning",
+		   wxOK | wxICON_EXCLAMATION);
+    }
+    card->TurnCard(facedown);
+}
+
+
+Pack::~Pack()
+{
+    for (m_topCard = 0; m_topCard < NumCards; m_topCard++)
+    {
+	    delete m_cards[m_topCard];
+    }
+};
+
+
+//------------------------------------------------------//
+// The Base class: holds the initial pile of four cards //
+//------------------------------------------------------//
+Base::Base(int x, int y) : Pile(x, y, 0, 12)
+{
+    m_topCard = -1;
+}
+
+
+bool Base::AcceptCard(Card* card)
+{
+    bool retval = FALSE;
+
+    if (m_topCard >= 0)
+    {
+	    if (m_cards[m_topCard]->GetSuit() == card->GetSuit() &&
+	        m_cards[m_topCard]->GetPipValue() - 1 == card->GetPipValue())
+	    {
+            retval = TRUE;
+        }
+    }
+    else
+    {
+		// pile is empty - ACCEPT
+        retval = TRUE;
+    }
+    return retval;
+}
+
+Base::~Base()
+{
+// nothing special at the moment
+};
+
+
+//----------------------------------------------------------------//
+// The Foundation class: holds the cards built up from the ace... //
+//----------------------------------------------------------------//
+Foundation::Foundation(int x, int y) : Pile(x, y, 0, 0)
+{
+    m_topCard = -1;
+}
+
+bool Foundation::AcceptCard(Card* card)
+{
+    bool retval = FALSE;
+
+    if (m_topCard >= 0)
+    {
+	    if (m_cards[m_topCard]->GetSuit() == card->GetSuit() &&
+	        m_cards[m_topCard]->GetPipValue() + 1 == card->GetPipValue())
+	    {
+            retval = TRUE;
+        }
+    }
+    else if (card->GetPipValue() == 1)
+    {
+	    // It's an ace and the pile is empty - ACCEPT
+        retval = TRUE;
+    }
+    return retval;
+}
+
+Foundation::~Foundation()
+{
+// nothing special at the moment
+};
+
+
+//----------------------------------------------------//
+// The Discard class: holds cards dealt from the m_pack //
+//----------------------------------------------------//
+Discard::Discard(int x, int y) : Pile(x, y, 19, 0)
+{
+    m_topCard = -1;
+}
+
+void Discard::Redraw(wxDC& dc)
+{
+    if (m_topCard >= 0)
+    {
+	    if (m_dx == 0 && m_dy == 0)
+	    {
+            m_cards[m_topCard]->Draw(dc, m_x, m_y);
+	    }
+	    else
+	    {
+	        int x = m_x;
+	        int y = m_y;
+	        for (int i = 0; i <= m_topCard; i++)
+	        {
+		        m_cards[i]->Draw(dc, x, y);
+		        x += m_dx;
+		        y += m_dy;
+		        if (i == 31)
+		        {
+		            x = m_x;
+                    y = m_y + CardHeight / 3;
+                }
+            }
+        }
+    }
+    else
+    {
+		Card::DrawNullCard(dc, m_x, m_y);
+    }
+}
+
+
+void Discard::GetTopCardPos(int& x, int& y)
+{
+    if (m_topCard < 0)
+    {
+	    x = m_x;
+	    y = m_y;
+    }
+    else if (m_topCard > 31)
+    {
+	    x = m_x + m_dx * (m_topCard - 32);
+	    y = m_y + CardHeight / 3;
+    }
+    else
+    {
+	    x = m_x + m_dx * m_topCard;
+	    y = m_y;
+    }
+}
+
+
+Card* Discard::RemoveTopCard(wxDC& dc, int m_xOffset, int m_yOffset)
+{
+    Card* card;
+
+    if (m_topCard <= 31)
+    {
+		card = Pile::RemoveTopCard(dc, m_xOffset, m_yOffset);
+    }
+    else
+    {
+    	int topX, topY, x, y;
+    	GetTopCardPos(topX, topY);
+		card = Pile::RemoveTopCard();
+		card->Erase(dc, topX - m_xOffset, topY - m_yOffset);
+		GetTopCardPos(x, y);
+		dc.SetClippingRegion(topX - m_xOffset, topY - m_yOffset,
+					 CardWidth, CardHeight);
+
+		for (int i = m_topCard - 31; i <= m_topCard - 31 + CardWidth / m_dx; i++)
+		{
+			m_cards[i]->Draw(dc, m_x - m_xOffset + i * m_dx, m_y - m_yOffset); 
+		}
+		if (m_topCard > 31)
+		{
+			m_cards[m_topCard]->Draw(dc, topX - m_xOffset - m_dx, topY - m_yOffset);
+		}
+		dc.DestroyClippingRegion();
+    }
+
+    return card;
+}
+
+
+Discard::~Discard()
+{
+// nothing special at the moment
+};

demos/forty/makefile.unx

@@ -0,0 +1,35 @@
+#
+# File:		Makefile for samples
+# Author:	Robert Roebling
+# Created:	1999
+# Updated:	
+# Copyright:	(c) 1998 Robert Roebling
+#
+# This makefile requires a Unix version of wxWindows
+# to be installed on your system. This is most often
+# done typing "make install" when using the complete
+# sources of wxWindows or by installing the two
+# RPM packages wxGTK.XXX.rpm and wxGTK-devel.XXX.rpm
+# under Linux.
+#
+
+CC = g++
+
+PROGRAM = forty
+
+OBJECTS = $(PROGRAM).o canvas.o card.o game.o pile.o playerdg.o scoredg.o scorefil.o
+
+# implementation
+
+.SUFFIXES:	.o .cpp
+
+.cpp.o :
+	$(CC) -c `wx-config --cflags` -o $@ $<
+
+all:    $(PROGRAM)
+
+$(PROGRAM):	$(OBJECTS)
+	$(CC) -o $(PROGRAM) $(OBJECTS) `wx-config --libs`
+
+clean: 
+	rm -f *.o $(PROGRAM)

demos/forty/playerdg.cpp

@@ -123,6 +123,8 @@ PlayerSelectionDialog::PlayerSelectionDialog(
 	}
 
 	Layout();
+    
+    CentreOnParent();
 }
 
 PlayerSelectionDialog::~PlayerSelectionDialog()

demos/forty/readme.txt

@@ -0,0 +1,86 @@
+Forty Thieves is a patience game played with two full packs of
+cards. At the start of the game forty cards are dealt on the
+eight 'bases' along the top of the window. The object of the
+game is to place all the cards onto the eight 'foundations'. The
+foundations are built starting with the ace and adding cards of
+the same suit up to the king. Cards are dealt from the pack and
+placed on the discard pile. Cards may be moved from the discard
+pile or one of the bases to a base or a foundation. Only one
+card can be moved at a time. Cards can only be placed on a base
+if the top card of the base is of the same suit and is one
+higher in pip value or the base is empty e.g. the eight of
+spades can only be placed on top of the nine of spades.
+
+When the mouse cursor is over a card which can be moved it
+changes to the 'hand' cursor. The card can then be moved by
+double clicking the left button.
+
+The mouse cursor also changes to a hand when a card is dragged
+by placing the cursor over the card and holding down the left
+button. This feature can be enabled and disabled by selecting
+the 'Helping hand' option from the Edit menu.
+
+The 'foundations' are the eight piles of cards down the left
+side of the window. When the game starts these piles are empty.
+The object of the game is to place all the cards on the
+foundations. An ace can be placed on any empty foundation. Other
+cards can only be placed on a foundation if the top card is of
+the same suit and is one lower in pip value e.g. the three of
+clubs can be placed on the four of clubs.
+
+The 'bases' are the ten piles of cards along the top of the
+window. At the start of the game four cards are dealt face up on
+each of the bases. A card can be added to a base if the base is
+empty or if the top card is of the same suit and is one higher
+in pip value e.g. the queen of hearts can be placed on the king
+of hearts The top card of a base can be moved onto another base
+or a foundation.
+
+Cards can be only moved one at a time. The top card of the pack
+can be dealt onto discard pile by placing the mouse cursor over
+the pack and pressing the left button. The number of cards
+remaining is displayed to the right of the pack.
+
+Cards can be moved from the discard pile or the bases either by
+'double-clicking' or by dragging. If the left button is
+double-clicked when the mouse cursor is over a card and it can
+move to another pile, it will do so. This is a quick way of
+moving cards when their destination is unambiguous.
+
+A card can be dragged by placing the mouse cursor over the card
+and holding down the left button. The card will follow the mouse
+cursor until the left button is released. If the card is over a
+pile on which it can be placed it will be added to that pile,
+otherwise it will be returned to the pile from which it was
+dragged.
+
+One point is scored for every card that is placed on a
+foundation. Since there are two packs of 52 cards the maximum
+score is 104. A record is kept of the number of games played,
+the number of games won, the current score and the average
+score. This information is displayed at bottom right of the
+window and is stored on disk between games. A game is deemed to
+have started if the cards have been dealt and any card has been
+moved. If the game is abandoned before it is finished (i.e. by
+starting a new game or closing window) it counts as a lost game.
+New players can be added by selecting the 'Player' option from
+the Game menu. A summary of players' scores can be displayed by
+selecting the 'Scores...' option from the Game menu.
+
+All moves are recorded and can be undone. To undo a move select
+the undo menu item from the Edit menu. A quicker way of undoing
+is to press the right mouse button (it doesn't matter where the
+mouse cursor is). Right button undo can be enabled and disabled
+by selecting the 'Right button undo' option from the Edit menu.
+Pressing the right mouse button with the control key pressed
+re-does a previously undone move.
+
+An empty base or two is very useful as it gives the opportunity
+to unscramble other bases. Try not to build onto kings which
+obscure valuable cards as it will be difficult to get to them
+later. The undo facility is very useful for going back and using
+'hindsight'.
+
+Don't be put off if you can't win every game. I reckon winning 1
+in 10 is pretty good (winning 1 in 3 is excellent).
+

demos/forty/scoredg.cpp

@@ -28,7 +28,7 @@
 #endif
 
 #if wxUSE_IOSTREAMH
-#if defined(__WXMSW__) && !defined(__GNUWIN32__)
+#if defined(__WXMSW__) && !defined(__GNUWIN32__) && !defined(__MWERKS__)
 #include <strstrea.h>
 #else
 #include <strstream.h>

demos/forty/scorefil.cpp

@@ -138,8 +138,8 @@ void ScoreFile::ReadPlayersScore(
 						int& games,
 						int& score)
 {
-	long check;
-	long myWins, myGames, myScore;
+	long check = 0;
+	long myWins = 0, myGames = 0, myScore = 0;
 
 	games = wins = score = 0;
 
@@ -171,7 +171,7 @@ void ScoreFile::WritePlayersScore(const char* player, int wins, int games, int s
     if (player)
 	{
 		m_config->SetPath("/General");
-		m_config->Write("LastPlayer", player);
+		m_config->Write("LastPlayer", wxString(player)); // Without wxString tmp, thinks it's bool in VC++
 
 		m_config->SetPath("/Players");
 		m_config->SetPath(player);

demos/fractal/.cvsignore

@@ -0,0 +1 @@
+

demos/fractal/Makefile.in

@@ -0,0 +1,21 @@
+#
+# File:		Makefile.in
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998 Julian Smart
+#
+# "%W% %G%"
+#
+# Makefile for fractal example (UNIX).
+
+top_srcdir = @top_srcdir@
+top_builddir = ../..
+program_dir = demos/fractal
+
+PROGRAM=fractal
+
+OBJECTS=$(PROGRAM).o
+
+include ../../src/makeprog.env
+

demos/fractal/makefile.unx

@@ -0,0 +1,35 @@
+#
+# File:		Makefile for samples
+# Author:	Robert Roebling
+# Created:	1999
+# Updated:	
+# Copyright:	(c) 1998 Robert Roebling
+#
+# This makefile requires a Unix version of wxWindows
+# to be installed on your system. This is most often
+# done typing "make install" when using the complete
+# sources of wxWindows or by installing the two
+# RPM packages wxGTK.XXX.rpm and wxGTK-devel.XXX.rpm
+# under Linux.
+#
+
+CC = gcc
+
+PROGRAM = fractal
+
+OBJECTS = $(PROGRAM).o
+
+# implementation
+
+.SUFFIXES:	.o .cpp
+
+.cpp.o :
+	$(CC) -c `wx-config --cflags` -o $@ $<
+
+all:    $(PROGRAM)
+
+$(PROGRAM):	$(OBJECTS)
+	$(CC) -o $(PROGRAM) $(OBJECTS) `wx-config --libs`
+
+clean: 
+	rm -f *.o $(PROGRAM)

demos/life/Makefile.in

@@ -0,0 +1,22 @@
+#
+# File:		makefile.unx
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998 Julian Smart
+#
+# "%W% %G%"
+#
+# Makefile for toolbar example (UNIX).
+
+top_srcdir = @top_srcdir@
+top_builddir = ../..
+program_dir = demos/life
+
+PROGRAM=life
+
+OBJECTS=$(PROGRAM).o dialogs.o game.o
+
+include ../../src/makeprog.env
+
+

demos/life/bitmaps/play.xpm

@@ -0,0 +1,24 @@
+/* XPM */
+static char *play_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"16 16 2 1",
+"  c None",
+". c Black",
+/* pixels */
+"                ",
+"                ",
+"                ",
+"    .           ",
+"    ...         ",
+"    .....       ",
+"    .......     ",
+"    .........   ",
+"    .......     ",
+"    .....       ",
+"    ...         ",
+"    .           ",
+"                ",
+"                ",
+"                ",
+"                "
+};

demos/life/bitmaps/reset.xpm

@@ -0,0 +1,24 @@
+/* XPM */
+static char *reset_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"16 16 2 1",
+"  c None",
+". c Black",
+/* pixels */
+"                ",
+"                ",
+"                ",
+"   ..      ..   ",
+"   ...    ...   ",
+"    ...  ...    ",
+"     ......     ",
+"      ....      ",
+"      ....      ",
+"     ......     ",
+"    ...  ...    ",
+"   ...    ...   ",
+"   ..      ..   ",
+"                ",
+"                ",
+"                "
+};

demos/life/bitmaps/stop.xpm

@@ -0,0 +1,24 @@
+/* XPM */
+static char *stop_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"16 16 2 1",
+"  c None",
+". c Black",
+/* pixels */
+"                ",
+"                ",
+"                ",
+"    ........    ",
+"    ........    ",
+"    ........    ",
+"    ........    ",
+"    ........    ",
+"    ........    ",
+"    ........    ",
+"    ........    ",
+"    ........    ",
+"                ",
+"                ",
+"                ",
+"                "
+};

demos/life/dialogs.cpp

@@ -0,0 +1,212 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dialogs.cpp
+// Purpose:     Life! dialogs
+// Author:      Guillermo Rodriguez Garcia, <guille@iies.es>
+// Modified by:
+// Created:     Jan/2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000, Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ==========================================================================
+// declarations
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// headers
+// --------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "dialogs.h"
+#endif
+
+// for compilers that support precompilation, includes "wx/wx.h"
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers
+#ifndef WX_PRECOMP
+    #include "wx/wx.h"
+#endif
+
+#include "wx/statline.h"
+#include "wx/spinctrl.h"
+
+#include "dialogs.h"
+#include "life.h"
+#include "game.h"
+
+// --------------------------------------------------------------------------
+// constants
+// --------------------------------------------------------------------------
+
+// IDs for the controls and the menu commands
+enum
+{
+    // listbox in samples dialog
+    ID_LISTBOX = 2001
+};
+
+// sample configurations
+#include "samples.inc"
+
+// --------------------------------------------------------------------------
+// event tables and other macros for wxWindows
+// --------------------------------------------------------------------------
+
+// Event tables
+BEGIN_EVENT_TABLE(LifeNewGameDialog, wxDialog)
+    EVT_BUTTON  (wxID_OK,    LifeNewGameDialog::OnOK)
+END_EVENT_TABLE()
+
+BEGIN_EVENT_TABLE(LifeSamplesDialog, wxDialog)
+    EVT_LISTBOX (ID_LISTBOX, LifeSamplesDialog::OnListBox)
+END_EVENT_TABLE()
+
+
+// ==========================================================================
+// implementation
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// LifeNewGameDialog
+// --------------------------------------------------------------------------
+
+LifeNewGameDialog::LifeNewGameDialog(wxWindow *parent, int *w, int *h)
+                 : wxDialog(parent, -1,
+                            _("New game"),
+                            wxDefaultPosition,
+                            wxDefaultSize,
+                            wxDEFAULT_DIALOG_STYLE | wxDIALOG_MODAL)
+{
+    m_w = w;
+    m_h = h;
+
+    // spin ctrls
+    m_spinctrlw = new wxSpinCtrl( this, -1 );
+    m_spinctrlw->SetValue(*m_w);
+    m_spinctrlw->SetRange(LIFE_MIN, LIFE_MAX);
+
+    m_spinctrlh = new wxSpinCtrl( this, -1 );
+    m_spinctrlh->SetValue(*m_h);
+    m_spinctrlh->SetRange(LIFE_MIN, LIFE_MAX);
+
+    // component layout
+    wxBoxSizer *inputsizer1 = new wxBoxSizer( wxHORIZONTAL );
+    inputsizer1->Add( new wxStaticText(this, -1, _("Width")), 1, wxCENTRE | wxLEFT, 20);
+    inputsizer1->Add( m_spinctrlw, 2, wxCENTRE | wxLEFT | wxRIGHT, 20 );
+
+    wxBoxSizer *inputsizer2 = new wxBoxSizer( wxHORIZONTAL );
+    inputsizer2->Add( new wxStaticText(this, -1, _("Height")), 1, wxCENTRE | wxLEFT, 20);
+    inputsizer2->Add( m_spinctrlh, 2, wxCENTRE | wxLEFT | wxRIGHT, 20 );
+
+    wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
+    topsizer->Add( CreateTextSizer(_("Enter board dimensions")), 0, wxALL, 10 );
+    topsizer->Add( new wxStaticLine(this, -1), 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 10);
+    topsizer->Add( inputsizer1, 1, wxGROW | wxLEFT | wxRIGHT, 5 );
+    topsizer->Add( inputsizer2, 1, wxGROW | wxLEFT | wxRIGHT, 5 );
+    topsizer->Add( new wxStaticLine(this, -1), 0, wxGROW | wxLEFT | wxRIGHT | wxTOP, 10);
+    topsizer->Add( CreateButtonSizer(wxOK | wxCANCEL), 0, wxCENTRE | wxALL, 10);
+
+    // activate
+    SetSizer(topsizer);
+    SetAutoLayout(TRUE);
+    topsizer->SetSizeHints(this);
+    topsizer->Fit(this);
+    Centre(wxBOTH);
+}
+
+void LifeNewGameDialog::OnOK(wxCommandEvent& WXUNUSED(event))
+{
+    *m_w = m_spinctrlw->GetValue();
+    *m_h = m_spinctrlh->GetValue();
+
+    EndModal(wxID_OK);
+}
+
+// --------------------------------------------------------------------------
+// LifeSamplesDialog
+// --------------------------------------------------------------------------
+
+LifeSamplesDialog::LifeSamplesDialog(wxWindow *parent)
+                 : wxDialog(parent, -1,
+                            _("Sample games"),
+                            wxDefaultPosition,
+                            wxDefaultSize,
+                            wxDEFAULT_DIALOG_STYLE | wxDIALOG_MODAL)
+{
+    m_value = 0;
+   
+    // create and populate the list of available samples
+    m_list = new wxListBox( this, ID_LISTBOX,
+        wxDefaultPosition,
+        wxDefaultSize,
+        0, NULL,
+        wxLB_SINGLE | wxLB_NEEDED_SB | wxLB_HSCROLL );
+
+    for (unsigned i = 0; i < (sizeof(g_shapes) / sizeof(LifeShape)); i++)
+        m_list->Append(g_shapes[i].m_name);
+
+    // descriptions
+    wxStaticBox *statbox = new wxStaticBox( this, -1, _("Description"));
+    m_life   = new Life( 16, 16 );
+    m_life->SetShape(g_shapes[0]);
+    m_canvas = new LifeCanvas( this, m_life, FALSE );
+    m_text   = new wxTextCtrl( this, -1,
+        g_shapes[0].m_desc,
+        wxDefaultPosition,
+        wxSize(300, 60),
+        wxTE_MULTILINE | wxTE_READONLY);
+
+    // layout components
+    wxStaticBoxSizer *sizer1 = new wxStaticBoxSizer( statbox, wxVERTICAL );
+    sizer1->Add( m_canvas, 2, wxGROW | wxCENTRE | wxALL, 5);
+    sizer1->Add( m_text, 1, wxGROW | wxCENTRE | wxALL, 5 );
+
+    wxBoxSizer *sizer2 = new wxBoxSizer( wxHORIZONTAL );
+    sizer2->Add( m_list, 0, wxGROW | wxCENTRE | wxALL, 5 );
+    sizer2->Add( sizer1, 1, wxGROW | wxCENTRE | wxALL, 5 );
+
+    wxBoxSizer *sizer3 = new wxBoxSizer( wxVERTICAL );
+    sizer3->Add( CreateTextSizer(_("Select one configuration")), 0, wxALL, 10 );
+    sizer3->Add( new wxStaticLine(this, -1), 0, wxGROW | wxLEFT | wxRIGHT, 10 );
+    sizer3->Add( sizer2, 1, wxGROW | wxCENTRE | wxALL, 5 );
+    sizer3->Add( new wxStaticLine(this, -1), 0, wxGROW | wxLEFT | wxRIGHT, 10 );
+    sizer3->Add( CreateButtonSizer(wxOK | wxCANCEL), 0, wxCENTRE | wxALL, 10 );
+
+    // activate
+    SetSizer(sizer3);
+    SetAutoLayout(TRUE);
+    sizer3->SetSizeHints(this);
+    sizer3->Fit(this);
+    Centre(wxBOTH);
+}
+
+LifeSamplesDialog::~LifeSamplesDialog()
+{
+    m_canvas->Destroy();
+    delete m_life;
+}
+
+int LifeSamplesDialog::GetValue()
+{
+    return m_value;
+}
+
+void LifeSamplesDialog::OnListBox(wxCommandEvent& event)
+{
+    if (event.GetSelection() != -1)
+    {
+        m_value = m_list->GetSelection();
+        m_text->SetValue(g_shapes[ event.GetSelection() ].m_desc);
+        m_life->SetShape(g_shapes[ event.GetSelection() ]);
+
+        m_canvas->DrawEverything(TRUE);     // force redraw everything
+        m_canvas->Refresh(FALSE);           // do not erase background
+    }
+}
+

demos/life/dialogs.h

@@ -0,0 +1,92 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        dialogs.h
+// Purpose:     Life! dialogs
+// Author:      Guillermo Rodriguez Garcia, <guille@iies.es>
+// Modified by:
+// Created:     Jan/2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000, Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _LIFE_DIALOGS_H_
+#define _LIFE_DIALOGS_H_
+
+#ifdef __GNUG__
+    #pragma interface "dialogs.h"
+#endif
+
+// for compilers that support precompilation, includes "wx/wx.h"
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers
+#ifndef WX_PRECOMP
+    #include "wx/wx.h"
+#endif
+
+#include "wx/spinctrl.h"
+
+#include "life.h"
+#include "game.h"
+
+
+// sample configurations
+extern LifeShape g_shapes[];
+
+
+// --------------------------------------------------------------------------
+// LifeNewGameDialog
+// --------------------------------------------------------------------------
+
+class LifeNewGameDialog : public wxDialog
+{
+public:
+    // ctor
+    LifeNewGameDialog(wxWindow *parent, int *w, int *h);
+
+    // event handlers
+    void OnOK(wxCommandEvent& event);
+
+private:
+    // any class wishing to process wxWindows events must use this macro
+    DECLARE_EVENT_TABLE();
+
+    int        *m_w;
+    int        *m_h;
+    wxSpinCtrl *m_spinctrlw;
+    wxSpinCtrl *m_spinctrlh;
+};
+
+// --------------------------------------------------------------------------
+// LifeSamplesDialog
+// --------------------------------------------------------------------------
+
+class LifeSamplesDialog : public wxDialog
+{
+public:
+    // ctor and dtor
+    LifeSamplesDialog(wxWindow *parent);
+    ~LifeSamplesDialog();
+
+    // members
+    int GetValue();
+
+    // event handlers
+    void OnListBox(wxCommandEvent &event);
+
+private:
+    // any class wishing to process wxWindows events must use this macro
+    DECLARE_EVENT_TABLE();
+
+    int         m_value;
+    wxListBox  *m_list;
+    wxTextCtrl *m_text;
+    LifeCanvas *m_canvas;
+    Life       *m_life;
+};
+
+#endif  // _LIFE_DIALOGS_H_

demos/life/game.cpp

@@ -0,0 +1,226 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        game.cpp
+// Purpose:     Life! game logic
+// Author:      Guillermo Rodriguez Garcia, <guille@iies.es>
+// Modified by:
+// Created:     Jan/2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000, Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ==========================================================================
+// declarations
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// headers
+// --------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "game.h"
+#endif
+
+// for compilers that support precompilation, includes "wx/wx.h"
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers
+#ifndef WX_PRECOMP
+    #include "wx/wx.h"
+#endif
+
+#include "game.h"
+
+// ==========================================================================
+// implementation
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// Life
+// --------------------------------------------------------------------------
+
+/* Format of the cell: (32 bit integer)
+ *
+ * 0yyyyyyy yyyyyy0x xxxxxxxxx xxx000ff
+ *
+ * y = y coordinate (13 bits)
+ * x = x coordinate (13 bits)
+ * f = flags (2 bits)
+ *
+ * OK, there is a reason for this, I promise :-). But I won't explain
+ * it now; it will be more clear when I implement the optimized life
+ * algorithm for large universes.
+ */
+
+Life::Life(int width, int height)
+{            
+    m_wrap = TRUE;
+    Create(width, height);
+}
+
+Life::~Life()
+{
+    Destroy();
+}
+
+void Life::Create(int width, int height)
+{
+    wxASSERT(width > 0 && height > 0 && m_cells.IsEmpty());
+
+    m_width = width;
+    m_height = height;
+
+    // preallocate memory to speed up initialization
+    m_cells.Alloc(m_width * m_height);
+    m_changed.Alloc(1000);
+
+    // add all cells
+    for (int j = 0; j < m_height; j++)
+        for (int i = 0; i < m_width; i++)
+            m_cells.Add( MakeCell(i, j, FALSE) );
+}
+
+void Life::Destroy()
+{
+    m_cells.Clear();
+    m_changed.Clear();
+}
+
+void Life::Clear()
+{
+    // set all cells in the array to dead
+    for (int j = 0; j < m_height; j++)
+        for (int i = 0; i < m_width; i++)
+            m_cells[j * m_width + i] &= ~CELL_ALIVE;
+}
+
+Cell Life::MakeCell(int i, int j, bool alive) const
+{
+    return (Cell)((j << 18) | (i << 5) | (alive? CELL_ALIVE : CELL_DEAD));
+}
+
+bool Life::IsAlive(int i, int j) const
+{
+    wxASSERT(i >= 0 && j >= 0 && i < m_width && j < m_height);
+
+    return (m_cells[j * m_width + i] & CELL_ALIVE);
+}
+
+bool Life::IsAlive(Cell c) const { return (c & CELL_ALIVE); };
+int  Life::GetX(Cell c) const    { return (c >> 5) & 0x1fff; };
+int  Life::GetY(Cell c) const    { return (c >> 18); };
+
+Cell Life::SetCell(int i, int j, bool alive)
+{
+    wxASSERT(i >= 0 && j >= 0 && i < m_width && j < m_height);
+
+    Cell c = MakeCell(i, j, alive);
+
+    m_cells[j * m_width + i] = c;
+    return c;
+}
+
+void Life::SetShape(LifeShape& shape)
+{
+    wxASSERT((m_width >= shape.m_width) && (m_height >= shape.m_height));
+
+    int i0  = (m_width - shape.m_width) / 2;
+    int j0  = (m_height - shape.m_height) / 2;
+    char *p = shape.m_data;
+
+    Clear();
+    for (int j = j0; j < j0 + shape.m_height; j++)
+        for (int i = i0; i < i0 + shape.m_width; i++)
+            SetCell(i, j, *(p++) == '*');
+}
+
+bool Life::NextTic()
+{
+    int i, j;
+
+    m_changed.Empty();
+
+    /* 1st pass. Find and mark deaths and births for this generation.
+     *
+     * Rules:
+     *   An organism with <= 1 neighbors will die due to isolation.
+     *   An organism with >= 4 neighbors will die due to starvation.
+     *   New organisms are born in cells with exactly 3 neighbors.
+     */
+    for (j = 0; j < m_height; j++)
+        for (i = 0; i < m_width; i++)
+        {
+            int neighbors = GetNeighbors(i, j);
+            bool alive    = IsAlive(i, j);
+
+            /* Set CELL_MARK if this cell must change, clear it
+             * otherwise. We cannot toggle the CELL_ALIVE bit yet
+             * because all deaths and births are simultaneous (it
+             * would affect neighbouring cells).
+             */
+            if ((!alive && neighbors == 3) ||
+                (alive && (neighbors <= 1 || neighbors >= 4)))
+            {
+                m_cells[j * m_width + i] |= CELL_MARK;
+                m_changed.Add( MakeCell(i, j, !alive) );
+            }
+            else
+                m_cells[j * m_width + i] &= ~CELL_MARK;
+        }
+
+    /* 2nd pass. Stabilize.
+     */
+    for (j = 0; j < m_height; j++)
+        for (i = 0; i < m_width; i++)
+        {
+            /* Toggle CELL_ALIVE for those cells marked in the
+             * previous pass. Do not clear the CELL_MARK bit yet;
+             * it is useful to know which cells have changed and
+             * thus must be updated in the screen.
+             */
+            if (m_cells[j * m_width + i] & CELL_MARK)
+                m_cells[j * m_width + i] ^= CELL_ALIVE;
+        }
+
+    return (!m_changed.IsEmpty());
+}
+
+int Life::GetNeighbors(int x, int y) const
+{
+    wxASSERT(x >= 0 && y >= 0 && x < m_width && y < m_height);
+
+    int neighbors = 0;
+
+    int i0 = (x)? (x - 1) : 0;
+    int j0 = (y)? (y - 1) : 0;
+    int i1 = (x < (m_width - 1))? (x + 1) : (m_width - 1);
+    int j1 = (y < (m_height - 1))? (y + 1) : (m_height - 1);
+
+    if (m_wrap && ( !x || !y || x == (m_width - 1) || y == (m_height - 1)))
+    {
+        // this is an outer cell and wraparound is on
+        for (int j = y - 1; j <= y + 1; j++)
+            for (int i = x - 1; i <= x + 1; i++)
+                if (IsAlive( ((i < 0)? (i + m_width ) : (i % m_width)),
+                             ((j < 0)? (j + m_height) : (j % m_height)) ))
+                     neighbors++;
+    }
+    else
+    {
+        // this is an inner cell, or wraparound is off
+        for (int j = j0; j <= j1; j++)
+            for (int i = i0; i <= i1; i++)
+                if (IsAlive(i, j))
+                     neighbors++;
+    }
+
+    // do not count ourselves
+    if (IsAlive(x, y)) neighbors--;
+
+    return neighbors;
+}
+

demos/life/game.h

@@ -0,0 +1,129 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        game.h
+// Purpose:     Life! game logic
+// Author:      Guillermo Rodriguez Garcia, <guille@iies.es>
+// Modified by:
+// Created:     Jan/2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000, Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _LIFE_GAME_H_
+#define _LIFE_GAME_H_
+
+#ifdef __GNUG__
+    #pragma interface "game.h"
+#endif
+
+// for compilers that support precompilation, includes "wx/wx.h"
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers
+#ifndef WX_PRECOMP
+    #include "wx/wx.h"
+#endif
+
+// --------------------------------------------------------------------------
+// constants
+// --------------------------------------------------------------------------
+
+// minimum and maximum table size, in each dimension
+#define LIFE_MIN 20
+#define LIFE_MAX 200
+
+// --------------------------------------------------------------------------
+// Cell and CellArray;
+// --------------------------------------------------------------------------
+
+typedef long        Cell;
+typedef wxArrayLong CellArray;
+
+// --------------------------------------------------------------------------
+// LifeShape
+// --------------------------------------------------------------------------
+
+class LifeShape
+{
+public:
+    LifeShape::LifeShape(wxString name,
+                         wxString desc,
+                         int width, int height, char *data,
+                         int fieldWidth = 20, int fieldHeight = 20,
+                         bool wrap = TRUE)
+    {
+        m_name        = name;
+        m_desc        = desc;
+        m_width       = width;
+        m_height      = height;
+        m_data        = data;
+        m_fieldWidth  = fieldWidth;
+        m_fieldHeight = fieldHeight;
+        m_wrap        = wrap;
+    }
+
+    wxString  m_name;
+    wxString  m_desc;
+    int       m_width;
+    int       m_height;
+    char     *m_data;
+    int       m_fieldWidth;
+    int       m_fieldHeight;
+    bool      m_wrap;
+};
+
+// --------------------------------------------------------------------------
+// Life
+// --------------------------------------------------------------------------
+
+class Life
+{
+public:
+    // ctor and dtor
+    Life(int width, int height);
+    ~Life();
+    void Create(int width, int height);
+    void Destroy();
+
+    // game field
+    inline int       GetWidth() const        { return m_width; };
+    inline int       GetHeight() const       { return m_height; };
+    inline void      SetBorderWrap(bool on)  { m_wrap = on; };
+
+    // cells
+    bool             IsAlive(int i, int j) const;
+    bool             IsAlive(Cell c) const;
+    int              GetX(Cell c) const;
+    int              GetY(Cell c) const;
+    const CellArray* GetCells() const        { return &m_cells; };
+    const CellArray* GetChangedCells() const { return &m_changed; };
+
+    // game logic
+    void Clear();
+    Cell SetCell(int i, int j, bool alive = TRUE);
+    void SetShape(LifeShape &shape);
+    bool NextTic();
+
+private:
+    int         GetNeighbors(int i, int j) const;
+    inline Cell MakeCell(int i, int j, bool alive) const;
+
+    enum CellFlags
+    {
+        CELL_DEAD    = 0x0000,  // is dead
+        CELL_ALIVE   = 0x0001,  // is alive
+        CELL_MARK    = 0x0002,  // will change / has changed
+    };
+
+    int       m_width;
+    int       m_height;
+    CellArray m_cells;
+    CellArray m_changed;
+    bool      m_wrap;
+};
+
+#endif  // _LIFE_GAME_H_

demos/life/life.cpp

@@ -0,0 +1,630 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        life.cpp
+// Purpose:     The game of life, created by J. H. Conway
+// Author:      Guillermo Rodriguez Garcia, <guille@iies.es>
+// Modified by:
+// Created:     Jan/2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000, Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ==========================================================================
+// declarations
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// headers
+// --------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "life.h"
+#endif
+
+// for compilers that support precompilation, includes "wx/wx.h"
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers
+#ifndef WX_PRECOMP
+    #include "wx/wx.h"
+#endif
+
+#include "wx/statline.h"
+
+#include "life.h"
+#include "game.h"
+#include "dialogs.h"
+
+// --------------------------------------------------------------------------
+// resources
+// --------------------------------------------------------------------------
+
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
+    // the application icon
+    #include "mondrian.xpm"
+
+    // bitmap buttons for the toolbar
+    #include "bitmaps/reset.xpm"
+    #include "bitmaps/play.xpm"
+    #include "bitmaps/stop.xpm"
+#endif
+
+// --------------------------------------------------------------------------
+// constants
+// --------------------------------------------------------------------------
+
+// IDs for the controls and the menu commands
+enum
+{
+    // menu items and toolbar buttons
+    ID_NEWGAME = 1001,
+    ID_SAMPLES,
+    ID_ABOUT,
+    ID_EXIT,
+    ID_CLEAR,
+    ID_START,
+    ID_STEP,
+    ID_STOP,
+    ID_WRAP,
+
+    // speed selection slider
+    ID_SLIDER
+};
+
+// --------------------------------------------------------------------------
+// event tables and other macros for wxWindows
+// --------------------------------------------------------------------------
+
+// Event tables
+BEGIN_EVENT_TABLE(LifeFrame, wxFrame)
+    EVT_MENU           (ID_NEWGAME, LifeFrame::OnNewGame)
+    EVT_MENU           (ID_SAMPLES, LifeFrame::OnSamples)
+    EVT_MENU           (ID_ABOUT,   LifeFrame::OnMenu)
+    EVT_MENU           (ID_EXIT,    LifeFrame::OnMenu)
+    EVT_MENU           (ID_CLEAR,   LifeFrame::OnMenu)
+    EVT_MENU           (ID_START,   LifeFrame::OnMenu)
+    EVT_MENU           (ID_STEP,    LifeFrame::OnMenu)
+    EVT_MENU           (ID_STOP,    LifeFrame::OnMenu)
+    EVT_MENU           (ID_WRAP,    LifeFrame::OnMenu)
+    EVT_COMMAND_SCROLL (ID_SLIDER,  LifeFrame::OnSlider)
+END_EVENT_TABLE()
+
+BEGIN_EVENT_TABLE(LifeCanvas, wxScrolledWindow)
+    EVT_PAINT          (            LifeCanvas::OnPaint)
+    EVT_SIZE           (            LifeCanvas::OnSize)
+    EVT_MOUSE_EVENTS   (            LifeCanvas::OnMouse)
+END_EVENT_TABLE()
+
+
+// Create a new application object
+IMPLEMENT_APP(LifeApp)
+
+// ==========================================================================
+// implementation
+// ==========================================================================
+
+// some shortcuts
+#define ADD_TOOL(a, b, c, d) \
+    toolBar->AddTool(a, b, wxNullBitmap, FALSE, -1, -1, (wxObject *)0, c, d)
+
+#define GET_FRAME() \
+    ((LifeFrame *) wxGetApp().GetTopWindow())
+
+// --------------------------------------------------------------------------
+// LifeApp
+// --------------------------------------------------------------------------
+
+// `Main program' equivalent: the program execution "starts" here
+bool LifeApp::OnInit()
+{
+    // create the main application window
+    LifeFrame *frame = new LifeFrame();
+
+    // show it and tell the application that it's our main window
+    frame->Show(TRUE);
+    SetTopWindow(frame);
+
+    // enter the main message loop and run the app
+    return TRUE;
+}
+
+// --------------------------------------------------------------------------
+// LifeFrame
+// --------------------------------------------------------------------------
+
+// frame constructor
+LifeFrame::LifeFrame() : wxFrame((wxFrame *)0, -1, _("Life!"), wxPoint(50, 50))
+{
+    // frame icon
+    SetIcon(wxICON(mondrian));
+
+    // menu bar
+    wxMenu *menuFile = new wxMenu("", wxMENU_TEAROFF);
+    wxMenu *menuGame = new wxMenu("", wxMENU_TEAROFF);
+
+    menuFile->Append(ID_NEWGAME, _("New game..."), _("Start a new game"));
+    menuFile->Append(ID_SAMPLES, _("Sample game..."), _("Select a sample configuration"));
+    menuFile->AppendSeparator();
+    menuFile->Append(ID_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
+    menuFile->AppendSeparator();
+    menuFile->Append(ID_EXIT, _("E&xit\tAlt-X"), _("Quit this program"));
+
+    menuGame->Append(ID_CLEAR, _("&Clear\tCtrl-C"), _("Clear game field"));
+    menuGame->Append(ID_START, _("&Start\tCtrl-S"), _("Start"));
+    menuGame->Append(ID_STEP, _("&Next\tCtrl-N"), _("Single step"));
+    menuGame->Append(ID_STOP, _("S&top\tCtrl-T"), _("Stop"));
+    menuGame->Enable(ID_STOP, FALSE);
+    menuGame->AppendSeparator();
+    menuGame->Append(ID_WRAP, _("&Wraparound\tCtrl-W"), _("Wrap around borders"), TRUE);
+    menuGame->Check (ID_WRAP, TRUE);
+
+    wxMenuBar *menuBar = new wxMenuBar();
+    menuBar->Append(menuFile, _("&File"));
+    menuBar->Append(menuGame, _("&Game"));
+    SetMenuBar(menuBar);
+
+    // tool bar
+    wxBitmap tbBitmaps[3];
+
+    tbBitmaps[0] = wxBITMAP(reset);
+    tbBitmaps[1] = wxBITMAP(play);
+    tbBitmaps[2] = wxBITMAP(stop);
+
+    wxToolBar *toolBar = CreateToolBar();
+    toolBar->SetMargins(5, 5);
+    toolBar->SetToolBitmapSize(wxSize(16, 16));
+    ADD_TOOL(ID_CLEAR, tbBitmaps[0], _("Clear"), _("Clear game board"));
+    ADD_TOOL(ID_START, tbBitmaps[1], _("Start"), _("Start"));
+    ADD_TOOL(ID_STOP , tbBitmaps[2], _("Stop"),  _("Stop"));
+    toolBar->EnableTool(ID_STOP, FALSE);
+    toolBar->Realize();
+
+    // status bar
+    CreateStatusBar(2);
+    SetStatusText(_("Welcome to Life!"));
+
+    // game
+    wxPanel *panel = new wxPanel(this, -1);
+    m_life         = new Life(20, 20);
+    m_canvas       = new LifeCanvas(panel, m_life);
+    m_timer        = new LifeTimer();
+    m_interval     = 500;
+    m_tics         = 0;
+    m_text         = new wxStaticText(panel, -1, "");
+    UpdateInfoText();
+
+    // slider
+    wxSlider *slider = new wxSlider(panel, ID_SLIDER,
+        5, 1, 10,
+        wxDefaultPosition,
+        wxSize(200, -1),
+        wxSL_HORIZONTAL | wxSL_AUTOTICKS);
+
+    // component layout
+    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
+    sizer->Add(new wxStaticLine(panel, -1), 0, wxGROW | wxCENTRE);
+    sizer->Add(m_canvas, 1, wxGROW | wxCENTRE | wxALL, 5);
+    sizer->Add(new wxStaticLine(panel, -1), 0, wxGROW | wxCENTRE);
+    sizer->Add(m_text, 0, wxCENTRE | wxTOP, 5);
+    sizer->Add(slider, 0, wxCENTRE | wxALL, 5);
+    panel->SetSizer(sizer);
+    panel->SetAutoLayout(TRUE);
+    sizer->Fit(this);
+    sizer->SetSizeHints(this);
+}
+
+LifeFrame::~LifeFrame()
+{
+    delete m_timer;
+    delete m_life;
+}
+
+void LifeFrame::UpdateInfoText()
+{
+    wxString msg;
+
+    msg.Printf(_("Generation: %u,  Interval: %u ms"), m_tics, m_interval);
+    m_text->SetLabel(msg);
+}
+
+// event handlers
+void LifeFrame::OnMenu(wxCommandEvent& event)
+{
+    switch (event.GetId())
+    {
+        case ID_START   : OnStart(); break;
+        case ID_STEP    : OnTimer(); break;
+        case ID_STOP    : OnStop(); break;
+        case ID_WRAP    :
+        {
+            bool checked = GetMenuBar()->GetMenu(1)->IsChecked(ID_WRAP);
+            m_life->SetBorderWrap(checked);
+            break;
+        }
+        case ID_CLEAR   : 
+        {
+            OnStop();
+            m_life->Clear();
+            m_canvas->DrawEverything(TRUE);
+            m_canvas->Refresh(FALSE);
+            m_tics = 0;
+            UpdateInfoText();
+            break;
+        }
+        case ID_ABOUT :
+        {
+            wxMessageBox(
+                _("This is the about dialog of the Life! sample.\n"
+                  "(c) 2000 Guillermo Rodriguez Garcia"),
+                _("About Life!"),
+                wxOK | wxICON_INFORMATION,
+                this);
+            break;
+        }
+        case ID_EXIT :
+        {
+            // TRUE is to force the frame to close
+            Close(TRUE);
+            break;
+        }
+    }
+}
+
+void LifeFrame::OnNewGame(wxCommandEvent& WXUNUSED(event))
+{
+    int w = m_life->GetWidth();
+    int h = m_life->GetHeight();
+
+    // stop if it was running
+    OnStop();
+
+    // dialog box
+    LifeNewGameDialog dialog(this, &w, &h);
+
+    // new game?
+    if (dialog.ShowModal() == wxID_OK)
+    {
+        // check dimensions
+        if (w >= LIFE_MIN && w <= LIFE_MAX &&
+            h >= LIFE_MIN && h <= LIFE_MAX)
+        {
+            // resize game field
+            m_life->Destroy();
+            m_life->Create(w, h);
+            
+            // tell the canvas
+            m_canvas->Reset();
+            m_canvas->Refresh();
+            m_tics = 0;
+            UpdateInfoText();
+        }
+        else
+        {
+            wxString msg;
+            msg.Printf(_("Both dimensions must be within %u and %u.\n"),
+                LIFE_MIN, LIFE_MAX);
+            wxMessageBox(msg, _("Error!"), wxOK | wxICON_EXCLAMATION, this);
+        }
+    }
+}
+
+void LifeFrame::OnSamples(wxCommandEvent& WXUNUSED(event))
+{
+    // stop if it was running
+    OnStop();
+
+    // dialog box
+    LifeSamplesDialog dialog(this);
+
+    // new game?
+    if (dialog.ShowModal() == wxID_OK)
+    {
+        int result = dialog.GetValue();
+
+        if (result == -1)
+            return;
+
+        int gw   = g_shapes[result].m_fieldWidth;
+        int gh   = g_shapes[result].m_fieldHeight;
+        int wrap = g_shapes[result].m_wrap;
+
+        // set wraparound (don't ask the user)
+        m_life->SetBorderWrap(wrap);
+        GetMenuBar()->GetMenu(1)->Check(ID_WRAP, wrap);
+
+        // need to resize the game field?
+        if (gw > m_life->GetWidth() || gh > m_life->GetHeight())
+        {
+            wxString s;
+            s.Printf(_("Your game field is too small for this configuration.\n"
+                       "It is recommended to resize it to %u x %u. Proceed?\n"),
+                       gw, gh);
+
+            if (wxMessageBox(s, _("Question"), wxYES_NO | wxICON_QUESTION, this) == wxYES)
+            {
+                m_life->Destroy();
+                m_life->Create(gw, gh);
+            }
+        }
+
+        // put the shape
+        m_life->SetShape(g_shapes[result]);
+
+        // tell the canvas about the change
+        m_canvas->Reset();
+        m_canvas->Refresh();
+        m_tics = 0;
+        UpdateInfoText();
+    }
+}
+
+void LifeFrame::OnStart()
+{
+    if (!m_running)
+    {
+        GetToolBar()->EnableTool(ID_START, FALSE);
+        GetToolBar()->EnableTool(ID_STOP,  TRUE);
+        GetMenuBar()->GetMenu(1)->Enable(ID_START, FALSE);
+        GetMenuBar()->GetMenu(1)->Enable(ID_STEP,  FALSE);
+        GetMenuBar()->GetMenu(1)->Enable(ID_STOP,  TRUE);
+
+        m_timer->Start(m_interval);
+        m_running = TRUE;
+    }
+}
+
+void LifeFrame::OnStop()
+{
+    if (m_running)
+    {
+        GetToolBar()->EnableTool(ID_START, TRUE);
+        GetToolBar()->EnableTool(ID_STOP,  FALSE);
+        GetMenuBar()->GetMenu(1)->Enable(ID_START, TRUE);
+        GetMenuBar()->GetMenu(1)->Enable(ID_STEP,  TRUE);
+        GetMenuBar()->GetMenu(1)->Enable(ID_STOP,  FALSE);
+        
+        m_timer->Stop();
+        m_running = FALSE;
+    }
+}
+
+void LifeFrame::OnTimer()
+{
+    if (m_life->NextTic())
+        m_tics++;
+    else
+        OnStop();
+
+    UpdateInfoText();
+    m_canvas->DrawEverything();
+    m_canvas->Refresh(FALSE);
+}
+
+void LifeFrame::OnSlider(wxScrollEvent& event)
+{
+    m_interval = event.GetPosition() * 100;
+
+    // restart timer if running, to set the new interval
+    if (m_running)
+    {
+        m_timer->Stop();
+        m_timer->Start(m_interval);
+    }
+
+    UpdateInfoText();
+}
+
+// --------------------------------------------------------------------------
+// LifeTimer
+// --------------------------------------------------------------------------
+
+void LifeTimer::Notify()
+{
+    GET_FRAME()->OnTimer();
+};
+
+// --------------------------------------------------------------------------
+// LifeCanvas
+// --------------------------------------------------------------------------
+
+// canvas constructor
+LifeCanvas::LifeCanvas(wxWindow *parent, Life *life, bool interactive)
+          : wxScrolledWindow(parent, -1, wxPoint(0, 0), wxSize(100, 100))
+{
+    m_life        = life;
+    m_interactive = interactive;
+    m_cellsize    = 8;
+    m_bmp         = NULL;
+    Reset();
+}
+
+LifeCanvas::~LifeCanvas()
+{
+    delete m_bmp;
+}
+
+void LifeCanvas::Reset()
+{
+    if (m_bmp)
+        delete m_bmp;
+
+    m_status   = MOUSE_NOACTION;
+    m_width    = CellToCoord(m_life->GetWidth()) + 1;
+    m_height   = CellToCoord(m_life->GetHeight()) + 1;
+    m_bmp      = new wxBitmap(m_width, m_height);
+    wxCoord w  = GetClientSize().GetX();
+    wxCoord h  = GetClientSize().GetY();
+    m_xoffset  = (w > m_width)?  ((w - m_width) / 2)  : 0;
+    m_yoffset  = (h > m_height)? ((h - m_height) / 2) : 0;
+
+    // redraw everything
+    DrawEverything(TRUE);
+    SetScrollbars(10, 10, (m_width + 9) / 10, (m_height + 9) / 10);
+}
+
+void LifeCanvas::DrawEverything(bool force)
+{
+    wxMemoryDC dc;
+
+    dc.SelectObject(*m_bmp);
+    dc.BeginDrawing();
+
+    // draw cells
+    const CellArray *cells =
+        force? m_life->GetCells() : m_life->GetChangedCells();
+
+    for (unsigned i = 0; i < cells->GetCount(); i++)
+        DrawCell(cells->Item(i), dc);
+
+    // bounding rectangle (always drawn - better than clipping region)
+    dc.SetPen(*wxBLACK_PEN);
+    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+    dc.DrawRectangle(0, 0, m_width, m_height);
+
+    dc.EndDrawing();
+    dc.SelectObject(wxNullBitmap);
+}
+
+void LifeCanvas::DrawCell(Cell c)
+{
+    wxMemoryDC dc;
+
+    dc.SelectObject(*m_bmp);
+    dc.BeginDrawing();
+
+    dc.SetClippingRegion(1, 1, m_width - 2, m_height - 2);
+    DrawCell(c, dc);
+
+    dc.EndDrawing();
+    dc.SelectObject(wxNullBitmap);
+}
+
+void LifeCanvas::DrawCell(Cell c, wxDC &dc)
+{
+    if (m_life->IsAlive(c))
+    {
+        dc.SetPen(*wxBLACK_PEN);
+        dc.SetBrush(*wxBLACK_BRUSH);
+        dc.DrawRectangle(CellToCoord( m_life->GetX(c) ),
+                         CellToCoord( m_life->GetY(c) ),
+                         m_cellsize,
+                         m_cellsize);
+    }
+    else
+    {
+        dc.SetPen(*wxLIGHT_GREY_PEN);
+        dc.SetBrush(*wxTRANSPARENT_BRUSH);
+        dc.DrawRectangle(CellToCoord( m_life->GetX(c) ),
+                         CellToCoord( m_life->GetY(c) ),
+                         m_cellsize,
+                         m_cellsize);
+        dc.SetPen(*wxWHITE_PEN);
+        dc.SetBrush(*wxWHITE_BRUSH);
+        dc.DrawRectangle(CellToCoord( m_life->GetX(c) ) + 1,
+                         CellToCoord( m_life->GetY(c) ) + 1,
+                         m_cellsize - 1,
+                         m_cellsize - 1);
+    }
+}
+
+// event handlers
+void LifeCanvas::OnPaint(wxPaintEvent& event)
+{
+    wxPaintDC dc(this);
+    wxMemoryDC memdc;
+
+    wxRegionIterator upd(GetUpdateRegion());
+    wxCoord x, y, w, h, xx, yy;
+
+    dc.BeginDrawing();
+    memdc.SelectObject(*m_bmp);
+
+    while(upd)
+    {
+        x = upd.GetX();
+        y = upd.GetY();
+        w = upd.GetW();
+        h = upd.GetH();
+        CalcUnscrolledPosition(x, y, &xx, &yy);
+
+        dc.Blit(x, y, w, h, &memdc, xx - m_xoffset, yy - m_yoffset);
+        upd++;
+    }
+
+    memdc.SelectObject(wxNullBitmap);
+    dc.EndDrawing();
+}
+
+void LifeCanvas::OnMouse(wxMouseEvent& event)
+{
+    if (!m_interactive)
+        return;
+
+    int x, y, xx, yy, i, j;
+
+    // which cell are we pointing at?
+    x = event.GetX();
+    y = event.GetY();
+    CalcUnscrolledPosition(x, y, &xx, &yy);
+    i = CoordToCell( xx - m_xoffset );
+    j = CoordToCell( yy - m_yoffset );
+
+    // adjust x, y to point to the upper left corner of the cell
+    CalcScrolledPosition( CellToCoord(i) + m_xoffset,
+                          CellToCoord(j) + m_yoffset,
+                          &x, &y );
+
+    // set cursor shape and statusbar text
+    if (i < 0 || i >= m_life->GetWidth() ||
+        j < 0 || j >= m_life->GetHeight())
+    {
+        GET_FRAME()->SetStatusText(wxEmptyString, 1);
+        SetCursor(*wxSTANDARD_CURSOR);
+    }
+    else
+    {
+        wxString msg;
+        msg.Printf(_("Cell: (%u, %u)"), i, j);
+        GET_FRAME()->SetStatusText(msg, 1);
+        SetCursor(*wxCROSS_CURSOR);
+    }
+
+    // button pressed?
+    if (!event.LeftIsDown())
+    {
+        m_status = MOUSE_NOACTION;
+    }
+    else if (i >= 0 && i < m_life->GetWidth() &&
+             j >= 0 && j < m_life->GetHeight())
+    {
+        bool alive = m_life->IsAlive(i, j);
+
+        // if just pressed, update status
+        if (m_status == MOUSE_NOACTION)
+            m_status = (alive? MOUSE_ERASING : MOUSE_DRAWING);
+
+        // toggle cell and refresh if needed
+        if (((m_status == MOUSE_ERASING) && alive) ||
+            ((m_status == MOUSE_DRAWING) && !alive))
+        {
+            wxRect rect(x, y, m_cellsize + 1, m_cellsize + 1);
+            DrawCell( m_life->SetCell(i, j, !alive) );
+            Refresh(FALSE, &rect);
+        }
+    }
+}
+
+void LifeCanvas::OnSize(wxSizeEvent& event)
+{
+    wxCoord w = event.GetSize().GetX();
+    wxCoord h = event.GetSize().GetY();
+    m_xoffset = (w > m_width)?  ((w - m_width) / 2)  : 0;
+    m_yoffset = (h > m_height)? ((h - m_height) / 2) : 0;
+
+    // allow default processing
+    event.Skip();
+}

demos/life/life.def

@@ -0,0 +1,7 @@
+NAME         Life
+DESCRIPTION  'Life! wxWindows application'
+EXETYPE      WINDOWS
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+HEAPSIZE     4048
+STACKSIZE    16000

demos/life/life.h

@@ -0,0 +1,136 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        life.h
+// Purpose:     The game of life, created by J. H. Conway
+// Author:      Guillermo Rodriguez Garcia, <guille@iies.es>
+// Modified by:
+// Created:     Jan/2000
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000, Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _LIFE_APP_H_
+#define _LIFE_APP_H_
+
+#ifdef __GNUG__
+    #pragma interface "life.h"
+#endif
+
+// for compilers that support precompilation, includes "wx/wx.h"
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers
+#ifndef WX_PRECOMP
+    #include "wx/wx.h"
+#endif
+
+#include "game.h"
+
+// --------------------------------------------------------------------------
+// LifeCanvas
+// --------------------------------------------------------------------------
+
+class LifeCanvas : public wxScrolledWindow
+{
+public:
+    // ctor and dtor
+    LifeCanvas(wxWindow* parent, Life* life, bool interactive = TRUE);
+    ~LifeCanvas();
+
+    // member functions
+    void Reset();
+    void DrawEverything(bool force = FALSE);
+    void DrawCell(Cell c);
+    void DrawCell(Cell c, wxDC &dc);
+    inline int CellToCoord(int i) const { return (i * m_cellsize); };
+    inline int CoordToCell(int x) const { return ((x >= 0)? (x / m_cellsize) : -1); };
+
+    // event handlers
+    void OnPaint(wxPaintEvent& event);
+    void OnMouse(wxMouseEvent& event);
+    void OnSize(wxSizeEvent& event);
+
+private:
+    // any class wishing to process wxWindows events must use this macro
+    DECLARE_EVENT_TABLE()
+
+    enum MouseStatus
+    {
+        MOUSE_NOACTION,
+        MOUSE_DRAWING,
+        MOUSE_ERASING
+    };
+
+    Life        *m_life;
+    wxBitmap    *m_bmp;
+    int          m_height;
+    int          m_width;
+    int          m_cellsize;
+    wxCoord      m_xoffset;
+    wxCoord      m_yoffset;
+    MouseStatus  m_status;
+    bool         m_interactive;
+};
+
+// --------------------------------------------------------------------------
+// LifeTimer
+// --------------------------------------------------------------------------
+
+// Life timer
+class LifeTimer : public wxTimer
+{
+public:
+    void Notify();
+};
+
+// --------------------------------------------------------------------------
+// LifeFrame
+// --------------------------------------------------------------------------
+
+class LifeFrame : public wxFrame
+{
+public:
+    // ctor and dtor
+    LifeFrame();
+    ~LifeFrame();
+
+    // member functions
+    void UpdateInfoText();
+
+    // event handlers
+    void OnMenu(wxCommandEvent& event);
+    void OnNewGame(wxCommandEvent& event);
+    void OnSamples(wxCommandEvent& event);
+    void OnStart();
+    void OnStop();
+    void OnTimer();
+    void OnSlider(wxScrollEvent& event);
+
+private:
+    // any class wishing to process wxWindows events must use this macro
+    DECLARE_EVENT_TABLE()
+
+    Life         *m_life;
+    LifeTimer    *m_timer;
+    LifeCanvas   *m_canvas;
+    wxStaticText *m_text;
+    bool          m_running;
+    long          m_interval;
+    long          m_tics;
+};
+
+// --------------------------------------------------------------------------
+// LifeApp
+// --------------------------------------------------------------------------
+
+class LifeApp : public wxApp
+{
+public:
+    virtual bool OnInit();
+};
+
+#endif  // _LIFE_APP_H_

demos/life/life.rc

@@ -0,0 +1,6 @@
+mondrian ICON "mondrian.ico"
+#include "wx/msw/wx.rc"
+
+reset BITMAP "bitmaps/reset.bmp"
+play  BITMAP "bitmaps/play.bmp"
+stop  BITMAP "bitmaps/stop.bmp"

demos/life/makefile.b32

@@ -0,0 +1,16 @@
+#
+# File:		makefile.b32
+# Author:	Julian Smart
+# Created:	1999
+# Updated:	
+# Copyright:
+#
+# Makefile : Builds sample for 32-bit BC++
+
+WXDIR = $(WXWIN)
+
+TARGET=life
+OBJECTS = $(TARGET).obj dialogs.obj game.obj
+
+!include $(WXDIR)\src\makeprog.b32
+

demos/life/makefile.bcc

@@ -0,0 +1,19 @@
+#
+# File:		makefile.bcc
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+#
+# Builds a BC++ 16-bit sample
+
+!if "$(WXWIN)" == ""
+!error You must define the WXWIN variable in autoexec.bat, e.g. WXWIN=c:\wx
+!endif
+
+WXDIR = $(WXWIN)
+
+TARGET=life
+OBJECTS=$(TARGET).obj dialogs.obj game.obj
+
+!include $(WXDIR)\src\makeprog.bcc
+

demos/life/makefile.dos

@@ -0,0 +1,17 @@
+#
+# File:		makefile.dos
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+#
+# Makefile : Builds 16-bit sample, VC++ 1.5
+# Use FINAL=1 argument to nmake to build final version with no debugging
+# info
+
+WXDIR = $(WXWIN)
+
+TARGET=life
+OBJECTS = $(TARGET).obj dialogs.obj game.obj
+
+!include $(WXDIR)\src\makeprog.msc
+

demos/life/makefile.g95

@@ -0,0 +1,16 @@
+#
+# File:         makefile.g95
+# Author:       Julian Smart
+# Created:      1999
+# Updated:
+# Copyright:    (c) Julian Smart, 1999
+#
+# Makefile for wxWindows sample (Cygwin/Mingw32).
+
+WXDIR = ../..
+
+TARGET=life
+OBJECTS = $(TARGET).o dialogs.o game.o
+
+include $(WXDIR)/src/makeprog.g95
+

demos/life/makefile.unx

@@ -0,0 +1,35 @@
+#
+# File:		Makefile for samples
+# Author:	Robert Roebling
+# Created:	1999
+# Updated:	
+# Copyright:	(c) 1998 Robert Roebling
+#
+# This makefile requires a Unix version of wxWindows
+# to be installed on your system. This is most often
+# done typing "make install" when using the complete
+# sources of wxWindows or by installing the two
+# RPM packages wxGTK.XXX.rpm and wxGTK-devel.XXX.rpm
+# under Linux.
+#
+
+CC = gcc
+
+PROGRAM = life
+
+OBJECTS = $(PROGRAM).o dialogs.o game.o
+
+# implementation
+
+.SUFFIXES:	.o .cpp
+
+.cpp.o :
+	$(CC) -c `wx-config --cflags` -o $@ $<
+
+all:    $(PROGRAM)
+
+$(PROGRAM):	$(OBJECTS)
+	$(CC) -o $(PROGRAM) $(OBJECTS) `wx-config --libs`
+
+clean: 
+	rm -f *.o $(PROGRAM)