From af83019e948713866dadc2a8b90602ff921f8607 Mon Sep 17 00:00:00 2001
From: Robin Dunn <robin@alldunn.com>
Date: Sat, 17 Aug 2002 19:08:21 +0000
Subject: [PATCH] Added wxWizard and the wizard page classes, as well as a
 wizard sample in the demo.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@16575 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
---
 wxPython/CHANGES.txt                  |    4 +-
 wxPython/demo/Main.py                 |    4 +-
 wxPython/demo/bmp_source/wiztest1.bmp |  Bin 0 -> 15718 bytes
 wxPython/demo/bmp_source/wiztest2.bmp |  Bin 0 -> 15718 bytes
 wxPython/demo/encode_bitmaps.py       |    5 +-
 wxPython/demo/images.py               |  453 ++++-
 wxPython/demo/wxWizard.py             |  115 ++
 wxPython/setup.py                     |   14 +
 wxPython/src/_wizardextras.py         |    3 +
 wxPython/src/helpers.h                |   46 +
 wxPython/src/msw/wizard.cpp           | 2300 +++++++++++++++++++++++++
 wxPython/src/msw/wizard.py            |  277 +++
 wxPython/src/wizard.i                 |  352 ++++
 13 files changed, 3535 insertions(+), 38 deletions(-)
 create mode 100644 wxPython/demo/bmp_source/wiztest1.bmp
 create mode 100644 wxPython/demo/bmp_source/wiztest2.bmp
 create mode 100644 wxPython/demo/wxWizard.py
 create mode 100644 wxPython/src/_wizardextras.py
 create mode 100644 wxPython/src/msw/wizard.cpp
 create mode 100644 wxPython/src/msw/wizard.py
 create mode 100644 wxPython/src/wizard.i

diff --git a/wxPython/CHANGES.txt b/wxPython/CHANGES.txt
index 11db24b6ce..721f50a619 100644
--- a/wxPython/CHANGES.txt
+++ b/wxPython/CHANGES.txt
@@ -148,7 +148,7 @@ Fixed the ActiveXWrapper problem.  Looks like when the win32com
 modules make a "callback" that they (incorrectly, IMHO) allocate a
 transient thread state structure.  Since wxPython is now saving
 tstates for it's own callbacks it ended up using garbage after
-win32com got rid of the tstate...
+win32com got rid of the temporary tstate...
 
 Added a generic static text control to wxPython.lib.stattext.  This is
 so things like Boa and PythonCard can have a static text that can
@@ -164,6 +164,8 @@ tools in your own scripts or apps as needed.
 Added a sample to the demo that catches various key events and
 displays the details of the event.
 
+Added wxWizard, wxWizardPage, wxWizardPageSimple and wxPyWizardPage.
+
 
 
 
diff --git a/wxPython/demo/Main.py b/wxPython/demo/Main.py
index 99b84e6406..09eba0f8cb 100644
--- a/wxPython/demo/Main.py
+++ b/wxPython/demo/Main.py
@@ -35,6 +35,7 @@ _treeList = [
         'wxMenu',
         'wxIEHtmlWin',
         'wxKeyEvents',
+        'wxWizard',
         ]),
 
     # managed windows == things with a caption you can close
@@ -43,6 +44,7 @@ _treeList = [
         'wxFrame',
         'wxMDIWindows',
         'wxMiniFrame',
+        'wxWizard',
         ]),
 
     # the common dialogs
@@ -60,7 +62,7 @@ _treeList = [
         'wxTextEntryDialog',
         ]),
 
-    # dialogs form libraries
+    # dialogs from libraries
     ('More Dialogs', [
         'ErrorDialogs',
         'ImageBrowser',
diff --git a/wxPython/demo/bmp_source/wiztest1.bmp b/wxPython/demo/bmp_source/wiztest1.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..d70d3f25bea80a37140ee1379acc3a59afd21e35
GIT binary patch
literal 15718
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

literal 0
HcmV?d00001

diff --git a/wxPython/demo/bmp_source/wiztest2.bmp b/wxPython/demo/bmp_source/wiztest2.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..7552e744efd8603b2a7fc28b3212da8e1b9b6bf6
GIT binary patch
literal 15718
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

literal 0
HcmV?d00001

diff --git a/wxPython/demo/encode_bitmaps.py b/wxPython/demo/encode_bitmaps.py
index 8abc04575e..489e6f6e64 100644
--- a/wxPython/demo/encode_bitmaps.py
+++ b/wxPython/demo/encode_bitmaps.py
@@ -55,7 +55,10 @@ command_lines = [
     "-a -u -n File1   -m #FFFFFF bmp_source/file1.bmp   images.py",
     "-a -u -n File2   -m #FFFFFF bmp_source/file2.bmp   images.py",
 
-    "-a -u -n NoIcon  bmp_source/noicon.png  images.py"
+    "-a -u -n NoIcon  bmp_source/noicon.png  images.py",
+
+    "-a -u -n WizTest1 bmp_source/wiztest1.bmp images.py",
+    "-a -u -n WizTest2 bmp_source/wiztest2.bmp images.py",
 
     ]
 
diff --git a/wxPython/demo/images.py b/wxPython/demo/images.py
index ae4dda8a1b..6c68ddafa1 100644
--- a/wxPython/demo/images.py
+++ b/wxPython/demo/images.py
@@ -7,7 +7,8 @@ import cStringIO
 
 
 def getMondrianData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00qID\
 ATx\x9c\xed\xd6;\n\x800\x10E\xd1{\xc5\x8d\xb9r\x97\x16\x0b\xad$\x8a\x82:\x16\
 o\xda\x84pB2\x1f\x81Fa\x8c\x9c\x08\x04Z{\xcf\xa72\xbcv\xfa\xc5\x08 \x80r\x80\
@@ -29,7 +30,8 @@ def getMondrianIcon():
 
 #----------------------------------------------------------------------
 def get_10s_Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
 \x00\x00O\x19o\x91\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x03\
 9IDATx\x9c\xed\x9dQr\x84 \x0c\x86C\xa7\x07\xf0\xc8\xec\x8d\xf7\x06\xf4\xa1K\
 \xab\xac\x84\x04\x92\x88K\xbe\x99>t\xab\xfb\xd3\xdf\x88I\xc41l\xdb\x06\x00\
@@ -73,7 +75,8 @@ def get_10s_Image():
 
 #----------------------------------------------------------------------
 def get_01c_Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
 \x00\x00O\x19o\x91\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x02\
 7IDATx\x9c\xed\x9dAR\xc4 \x14D\x1b\xcb\x03pd\xe6\xc6s\x03\\h\x94!\xa4\xc9L\
 \x95\xe1k\xf7\xabr\xa1\xb80\xaf\x9a\xff\x03\x98I\xca9\x03\x00\xee\xf7{\x85\
@@ -108,7 +111,8 @@ def get_01c_Image():
 
 #----------------------------------------------------------------------
 def get_12h_Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
 \x00\x00O\x19o\x91\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x07\
 \xcfIDATx\x9c\xed][\x96\xe3*\x0c,r\xee\x02\xb2\xe4\xcc\x8e{\x05\xc3\xfd\xb0\
 \x05\x92\x90\x04\x062\x9d\x99v\x9d\x93\xf6\x03[@Y\xe8\x81I:=\x9fO\x00\xc0\
@@ -197,7 +201,8 @@ def get_12h_Image():
 
 #----------------------------------------------------------------------
 def get_13d_Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00G\x00\x00\x00`\x08\x06\x00\
 \x00\x00O\x19o\x91\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x07\
 bIDATx\x9c\xed]Qr\xe3 \x0c}t\xf6\x009\xb2{\xe3\x9e\xa0\xec\x87##\x84$@\x90dw\
 \x927\x931\xb61\x86gIH\xc2n\xd3\xedv\x03\x00\xfc\xfc\xfcd|\x00\x00\xb8\xddn\
@@ -282,7 +287,8 @@ def get_13d_Image():
 
 #----------------------------------------------------------------------
 def getBackgroundData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x96\x00\x00\x00\x96\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x96\x00\x00\x00\x96\x08\x06\
 \x00\x00\x00<\x01q\xe2\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
  \x00IDATx\x9c\\\xbd\xcd\x8a\xe4\xca\xb2\xb6\xf9\x88r\x07s\x90\x83;\xa4 u ?\
 \xc8\x03\xfb\x83\xdd\xb0\x1b\xba\xa1\xa7=\xe8a_U]]\xdf\xc2\x1e\xec\x86<P\x0b\
@@ -1775,7 +1781,8 @@ def getBackgroundImage():
 
 #----------------------------------------------------------------------
 def getTestStarData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00P\x00\x00\x00P\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00P\x00\x00\x00P\x08\x06\x00\
 \x00\x00\x8e\x11\xf2\xad\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\n IDATx\x9c\xed\x9bk\xac\\U\x15\xc7\xffk\x9f33\x17>\x98*\x97\x98\xd6\
 \xb6\x12^\x11\xa9\x12\xd3\x06\x0b\x96Rh\xa1\xd2\x82\xb5\x12bjK_\xf7\xb6M{mUR\
@@ -1889,7 +1896,8 @@ def getTestStarImage():
 
 #----------------------------------------------------------------------
 def getTestStar2Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00P\x00\x00\x00P\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00P\x00\x00\x00P\x08\x06\x00\
 \x00\x00\x8e\x11\xf2\xad\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\n\x05IDATx\x9c\xed\x9b{\xac\x1cU\x1d\xc7?gf\x1f\x17\x12M\x94\x12C\xa1H@\
 \x89\xa4\xa5@[j)\xb5i\x90\x04\x9fT(\xa0\xe5M\xef-\xcf\xdeR\x0b\x92h\x88\x1a\
@@ -2002,7 +2010,8 @@ def getTestStar2Image():
 
 #----------------------------------------------------------------------
 def getTestMaskData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00P\x00\x00\x00P\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00P\x00\x00\x00P\x08\x06\x00\
 \x00\x00\x8e\x11\xf2\xad\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x03\xb5IDATx\x9c\xdd\\\xd9\x8e\xe4 \x0c\x84\xd5\xfc\xff/\xb3Oi\xd1\x8c\
 \x01\x1b\x97MeJZ\xedC\'\x1c\x85\xf1\x9d\xa9\xad\xb5V:\xd4Z\x8b\x15\xc3\x10SD\
@@ -2052,7 +2061,8 @@ def getTestMaskImage():
 
 #----------------------------------------------------------------------
 def getTest2Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00@\x00\x00\x00@\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00@\x00\x00\x00@\x08\x06\x00\
 \x00\x00\xaaiq\xde\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\taI\
 DATx\x9c\xe5\x9bMl\x1b\xc7\x15\xc7\x7f\xc3\xe5\x92\x92HQ\x12e}\xc5\x96+;\x89\
 $H\x89[UI\r\xd4(\x1a\xd7p\x1a\x14v\xe0\\\x8a\x00\xbew\x9b\xa2\xf0%\xe8\xcdA\
@@ -2159,7 +2169,8 @@ def getTest2Image():
 
 #----------------------------------------------------------------------
 def getRobinData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00h\x00\x00\x00\x96\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00h\x00\x00\x00\x96\x08\x06\
 \x00\x00\x002\x84\xcd\xc8\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00 \x00IDATx\x9c\x94\xbd\xc7\x92,Yv\xae\xf7m\xe9\xee!2R\x1dY\xaa\xbb\xd0\
 \xdd\x00\x1a\x970\xd0\x88\x8b\xcb\x11\x06\x9c\xd0\xf8\x08\x9cr\xc4\xc7\xe0Cq\
@@ -3194,7 +3205,8 @@ def getRobinImage():
 
 #----------------------------------------------------------------------
 def getBulb1Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00(\x00\x00\x00(\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00(\x00\x00\x00(\x08\x06\x00\
 \x00\x00\x8c\xfe\xb8m\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x00\xd4IDATx\x9c\xed\xd8Q\x0b\xc20\x0c\x04\xe0\x8b\xf8\xff\xffr}\x90\x80\
 \xcc\xea\x9a\xbb\xcc\x96\x9a{\x1cc|\xa4]\x9a\xcd\x80\xd6\xb0pn\xb3\x01g)\xa0\
@@ -3216,7 +3228,8 @@ def getBulb1Image():
 
 #----------------------------------------------------------------------
 def getBulb2Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00(\x00\x00\x00(\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00(\x00\x00\x00(\x08\x06\x00\
 \x00\x00\x8c\xfe\xb8m\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x01\x8dIDATx\x9c\xed\x98M\x8e\xc20\x0c\x85\x9d\x11]\xf7d\xe5\xb0p\xb2\xae\
 \xbb\xc8,\x82E\xe3\xf8\x97\x04\x884\xf3\xa4.\xa0\xa9\xf3\xf1\xec8)\t g\x98X?\
@@ -3245,7 +3258,8 @@ def getBulb2Image():
 
 #----------------------------------------------------------------------
 def getCalendarData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\
 \xa4IDATx\x9c\xc5WQn\xc30\x08}\xaev/\xfbfc7#\'c\x1f\x15\x1e&8\xc1\xad\xa7>\
 \xc9jq\x08<? J\x8a\x88\xc8O)\x00\x80ol\x82H\xda\xf5\xa1\xc9w\xa2,\xc4\xfc\n\
@@ -3274,7 +3288,8 @@ def getCalendarImage():
 
 #----------------------------------------------------------------------
 def getDbDecData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00zID\
 ATx\x9c\xed\xd5K\n\xc0 \x0c\x04\xd0\x89x\xafz\xf4\xf4dv\xd5\x82\x18\x17JH\
 \xba\x98,\x83:\x0f\xf1#\xaa\xda\x91X\xc5j\xb6v\x99\x83W}W@d\xf8\x04\x88\x0e\
@@ -3292,7 +3307,8 @@ def getDbDecImage():
 
 #----------------------------------------------------------------------
 def getDecData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00qID\
 ATx\x9c\xed\xd4\xd1\r\xc0 \x08\x04Pl:\x18\xa3\xdffu\x00\x8bb\xcc\xe1\xcf\xf1\
 mr\x0fT\x1a\x80\xcf.\xd6\x939\xe4\xf0{\x00f\xf8\x12\xc0\x0e\x9f\x02*\xc2\xcd\
@@ -3310,7 +3326,8 @@ def getDecImage():
 
 #----------------------------------------------------------------------
 def getPtData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00MID\
 ATx\x9c\xed\xd3\xb1\r\x00 \x0c\x03A\x83\x18,\xa3{3\xa8`\x80P\xb8yW\xa9\x92S$\
 \x0f\xdb[\xc1\xcc\xe4q\x00\x92\xb4\xee`WkA\x95\xbf\x00\xf1\x0f\x00\x00\x10\
@@ -3326,7 +3343,8 @@ def getPtImage():
 
 #----------------------------------------------------------------------
 def getDbIncData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00xID\
 ATx\x9c\xed\xd51\x0e\xc0 \x0c\x03@S\xf1\xaf\xf2t\xf32\xbav \x10\tH;\xd8#H\
 \xf8\x04\x91H$\x1b>\xccem\x94r\xbb\xd6\x8e\x01\xa2\x10C@\x04b\n\xb0\xb2\x0b\
@@ -3344,7 +3362,8 @@ def getDbIncImage():
 
 #----------------------------------------------------------------------
 def getIncData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00jID\
 ATx\x9c\xed\xd01\x0e\xc00\x08\x03@R\xe5a<\xdd?k\xd7*C \x12\x0e\x8bY\x91\xf0\
 \xe1\x01\xe0\xb5\xc6yvK\x87\xf7\x02n B\x00\x1b\x91\x020\x11\xf3\xe4\xb8\xc3\
@@ -3361,7 +3380,8 @@ def getIncImage():
 
 #----------------------------------------------------------------------
 def getNewData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
 \x00\x00\x00\xedsO/\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x00VIDATx\x9cc\x14\x10\x10`\xa0\x04\xb0 s>|\xf8\xf0\x1f\x9fb\x01\x01\x01Ft1\
 &t\x81\xff\xff\xffc\xc5\xb8,\xc00\x00\x1f\xf8\xff\xff?\x86!$\x19\xc0\xc8\xc8\
@@ -3378,7 +3398,8 @@ def getNewImage():
 
 #----------------------------------------------------------------------
 def getOpenData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
 \x00\x00\x00\xedsO/\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x00\x8eIDATx\x9c\xa5\x92\xd1\r\xc4 \x0cC\x9dS\x07\xf0\xc8\x8c\xec\r\xd2\x0f\
 \x14\x91p\xa8W8\xff@\x10\xcf8(F\x12\xff\xe8z{Q\x92\xc7\x9e\xa4m\x19H\xf2\x0c\
@@ -3397,7 +3418,8 @@ def getOpenImage():
 
 #----------------------------------------------------------------------
 def getCopyData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
 \x00\x00\x00\xedsO/\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x00\xa0IDATx\x9c\xa5\x93\xeb\r\xc3 \x0c\x84\xcfQ\x06\xb8Q\xbbA\xe9\x06\x1d\
 \xd5\x1b\\\x7f$$\x06\x9c\xd2*\'Y\xe2\x11\x7fp\x87b$qG+\x00\xb8\xbb\xb2M\x926\
@@ -3417,7 +3439,8 @@ def getCopyImage():
 
 #----------------------------------------------------------------------
 def getPasteData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
 \x00\x00\x00\xedsO/\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x00\xa3IDATx\x9c\xa5\x93\xeb\r\xc30\x08\x84\x8f\xaa\x03\\6\xed\x06\xa1\x1bt\
 T6\xb8\xfeH\xdc\xe0G\x1eUN\xb2\x84\xc1|`$\x8c$\xee\xe89rF\x84\xf2\x9d\xa4\
@@ -3437,7 +3460,8 @@ def getPasteImage():
 
 #----------------------------------------------------------------------
 def getTog1Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
 \x00\x00\x00\xedsO/\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x00WIDATx\x9cc\x14\x10\x10`\xa0\x040Q\xa4\x9b\x81\x81\x81\x05\xc6\xf8\xf0\
 \xe1\xc3\x7fR4\n\x08\x080R\xe4\x82\x82\x82\x82\xff(.\x80\x99\x88\x0c`\xaejhh\
@@ -3454,7 +3478,8 @@ def getTog1Image():
 
 #----------------------------------------------------------------------
 def getTog2Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0f\x08\x06\
 \x00\x00\x00\xedsO/\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x00>IDATx\x9cc\x14\x10\x10`\xa0\x040Q\xa4\x9b\x1a\x06\xb0 s>|x\xff\x9f\x14\
 \xcd\x02\x02\x82\x8c\x14\xbb\x80\x91P \xc2\\%  \xc8\x88M~\xe0\x03q\xd4\x80\
@@ -3470,7 +3495,8 @@ def getTog2Image():
 
 #----------------------------------------------------------------------
 def getSmilesData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x02\xa3IDATx\x9ce\x93\xdfkSg\x18\xc7?\xe7WL\x1b\xa2\x07!U\xa9\x89\xe9j\
 \x90H\x87\x0cA\x86"\xb2\xf6B\xa1\xe0\x8d\xca\x19.\x88XJ\xa0\xb7R\xbc\x14\xbc\
@@ -3509,7 +3535,8 @@ def getSmilesImage():
 
 #----------------------------------------------------------------------
 def getGridBGData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00T\x00\x00\x00T\x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00T\x00\x00\x00T\x08\x06\x00\
 \x00\x00\x1ck\x10\xc1\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 \x01\x7fIDATx\x9c\xed\xdc[j\x821\x14\x00\xe1\xa3\x06/\xad\x82\x9bw\x0b\xbeuo\
 \x85\xdajE\xd1\r\x84_\x88\x93\x90\xc0|\x8f\rX\x19\x08\x1c\x92\xb4\xb3\xc3\
@@ -3537,7 +3564,8 @@ def getGridBGImage():
 
 #----------------------------------------------------------------------
 def getSmallUpArrowData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x00<IDATx\x9cc\x14\x10\x10`\xa0\x040Q\xa4{h\x18\xf0\xe1\xc3\x87\xffd\
 \x1b\x00\xd3\x8c\xcf\x10\x9c\x06\xa0k\xc2e\x08m\xc2\x00\x97m\xd8\xc41\x0c \
@@ -3553,7 +3581,8 @@ def getSmallUpArrowImage():
 
 #----------------------------------------------------------------------
 def getSmallDnArrowData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x00HIDATx\x9cc\x14\x10\x10`\xa0\x040Q\xa4{\xd4\x00\x06\x06\x06\x06\x06\
 \x16t\x81\x0f\x1f>\xfc\'\xa4I@@\x80\x11\xa7\x0b\x90%\ti\xc6j\x00>C\xb0\x89\
@@ -3569,7 +3598,8 @@ def getSmallDnArrowImage():
 
 #----------------------------------------------------------------------
 def getFolder1Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x00\xa5IDATx\x9c\xe5S\xc1\r\xc4 \x0c3U\x07p\'jG\xb8Q\xd8\x00\x8f\xc0(\
 \x8c@\'*\x1b\xe4^\x9cJ\xa9z\xd5\xf5y\x91\x90\x05J\x1c;"\x8e$\x9e\xc4\xb8\xbf\
@@ -3589,7 +3619,8 @@ def getFolder1Image():
 
 #----------------------------------------------------------------------
 def getFolder2Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x00\xa5IDATx\x9c\xe5S\xc1\r\xc3 \x103Q\x06p\'*#d\x146\x88G`\x14F\xa0\
 \x13\x95\r\xae\x8f\x8a*\x84(\xa5\xca\xb3\x96\x90\x05\xba3\xe7\x83s$q\x05\xf3\
@@ -3608,7 +3639,8 @@ def getFolder2Image():
 
 #----------------------------------------------------------------------
 def getFolder3Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x00rIDATx\x9c\xad\x92A\x0e\x800\x08\x04\x07\xd3\x07\xec\x93\xfb\xe4\xfe\
 \xa0\x1eL\x8dUljq\xaf\xc0L \x98$"\xd9B\xd3@\x02(\xa5\xd4{A\x92M\x03\x00\xea\
@@ -3626,7 +3658,8 @@ def getFolder3Image():
 
 #----------------------------------------------------------------------
 def getFile1Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x00cIDATx\x9c\xed\x93A\n\xc00\x08\x04k\xe9\x03\xe6\xff\xaf\xdc\x1f\xa4\
 \'/\x89\x9a\xa4\xb9vA\x10\xb2\xac#D\x03\xae\x13=\xdeHj\x95\x11\xb02\xa02Ij\
@@ -3643,7 +3676,8 @@ def getFile1Image():
 
 #----------------------------------------------------------------------
 def getFile2Data():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
 \x00\x00aIDATx\x9cc\x14\x10\x10`\xa0\x04\xb0\xc0\x18\x1f>|\xf8\x8fO\xa1\x80\
 \x80\x00#6q&d\xce\x7f\x1c\x18\x9f\x05L\xe8\x02\x8ch4\xb2\x0b\xb0\x19\x82a\
@@ -3660,7 +3694,8 @@ def getFile2Image():
 
 #----------------------------------------------------------------------
 def getNoIconData():
-    return '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
 \x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00\
 \x8dIDATx\x9c\xed\x95Y\n\x800\x0cD\x13\xf1\x00s\xffS\xf6\x06\xfaU\x18J\xd4\
 \xd6\x85\x14\x9c\xfc\x94L\x97<h\x16\x07`\x99\xb6\xa4F\x17\x80\x00\xccl\x1d9\
@@ -3677,3 +3712,351 @@ def getNoIconImage():
     stream = cStringIO.StringIO(getNoIconData())
     return wxImageFromStream(stream)
 
+#----------------------------------------------------------------------
+def getWizTest1Data():
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00t\x00\x00\x01\x04\x08\x06\
+\x00\x00\x00\xf9\xcf\x10R\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
+\x00\x0f\xdfIDATx\x9c\xed]K\xb6\xe3(\x0cU\xf5\xa9MU\x86\xd9\xd6\xcb\xd0\xd9\
+\x96\x87\xaeeU\x0f\xfc\t\x06\x01\x12\x16\x1f+\xba\xe7\xf4\xe9\xd4\xb3-d\xf0E\
+ \t\xf8\xb5,\xcb\xbf\xc7c\x06\xc3\x05L\x00\xf0\xfa\xd9~\xbf\xcf\xbf\x81p\r\
+\xbb\xaf\xf0\xdao\xb1\x97\xfa6L\xdb\xff_?\x00/\xb8\xd6@\xdc\x0f q\xed?\x89w\
+\xfb\x0e\xfc\xac\x8d8m\xbf\x07\x8514\x8b\x9dU\xefj\xac\x92\xecr\x8d\xa1\x01~\
+\xe0`\xe3\xc0L\x8c\xc1\x18z\xc2O5\xe6$\xaf\t\xb2\xfd\xd7:\xca\xfd\xc3\x7fw\
+\xc3\x90\xd8\x18\xfa\xee\xabE\x17\x10\xd8X\xc2\x9c\xa3.\x192\xa5\xd8\x0eoc\
+\xa86|\x19C\xa5F\x9f\x992\xc8\xacz\xe7\x9fs\xef#80\x8c\xa1\xca\xa0\x9f\xa1\
+\xaeG\xe7\xca\xe83\xc9J\x80\x13\xfb\xb3\xb6\x17\xa9o\x9f}\xae^~\xd9\x13Du6\
+\x86*\x83b\x86\xd6\x9a\x1f\x12\xd8\x95\x1d\x01#\xe00t\x7f?c\xa8~\xe8bh\xec+\
+\xdf\xff\xdd\xcb\xc7J\xaa_\xc2(\x97\xf0\x9c1T\x19\x140\xb4\xd4\xff\x1a{ga\
+\x1fkvt\xbc\x81mC\x11\xbd\xcd\x86\xea\xc3\x8d\x19\xca\xf4\xbf\x96\xbec\x8a9~\
+\xd9\xa5\xd7\x04\xed\xfeM\xc3g?\xf1\x97E_\xfcBQ~z\xc9!s\xc0\xc1\xd7=\x03\xdc\
+?\xe8_\'\x00\x80\xe9\r\xcb\xf3y8\x87\xd6,\x03\x81"_ #\xa7\x01~\xdd+\xeb/1\
+\x00\xda\x1a\xf31;\xef"\xda\x08\xa5\x83/\xc25A\xb6\xdf\x88\xa183\xa3\xb8\t\
+\xa3\xa4q\x13\x1b\x9a\xff\xb2wv.\xcf\'\x00\x00<@\xb0\xd7\x99\x00\xf2Ib\x8e\
+\x9e\x1dm\xe8\r\x1a\x94\xc9\xcc*\xe5gF\xc8Go\xb0\xdb\xec\xb7\xf7\xf7\x8a\xf0\
+\xca\x1b\xdf\x86\xba\xe1/\x00\xba\r\x95\xaaL\xd2\xb4\xa5dJT\xc7I\xa1\xc6\xb1\
+\xb0,\x7f\xcf]\xae\x82w*\xc1\xc0\x8e\x05\xaa=\xdau\x7fz\xcfK\xbc\x13\x819Ruw\
+\xd9\xf5\xb7B\rC\xc3.\xb7\xb7\xed\xed\x83a\x18:M\x00/w\xa4\x08\x90\x19\xe5\
+\xe5$^x\xa7\t\xf0\x8f\xe3\x02s\xf2(\r\x9fyX\x96\xe5\x1f\xc0\xbf\xae\xff-\xcb\
+\xf2oY\x96\x7f0M\x97d\xc04}d]\xd4g\x97\xd5\xbbn\xb8\xff\xf5g\xe8\x04p\xb2\
+\x7f\xc1\xc8\x8e\xcaL\x01\x1b\xba13\xfc\xbb\x90\xa3?S\xb6\x1e\x1b\xba\xbd\
+\xc01B\x9dg\xbe\r\x14\xb0\xa1\xfbHy\xd7\xa5H\x8f\xce\xe8\xcfP\x00\x80\x17\
+\xc0\xb2<\xcf\x95\t\xc0\x9a\x87\x85\x9e"\xe6;M\x00\x8f9\xf2Q]\x9es\xd2\xca\
+\xd7\xc3\xd0\x1d\x17\x98Z<\x0f\xf5\x98\xbd<\x9f\xb7\x9e\xc3\x8e\xe1)r\xbcAh\
+\xb7\x07\x90\xffJ\x83\x91)\xad\xe8\xbdg8}D\x9b.\xe2\xb1\xd5$dF\xb9\xbf\x0fa=\
+\xe1T\xd2\xe3\xf1\x07`\xc2>\xb0\x9c\x8e\xfeKg\xee\xdf\x98\xe9be\xa6\xc3N\xbf\
+w\xa8mO\xa3\xe5\xd1\xcb\xed\xcc\xd0\xb87(\xe8B\xe79mC}\xa6e\xde)\xb0\xd9\xd8\
+\x9c\xb3\t37\xa8\xb4\xa1>\x1c\x16\xe5F\xafd\x1b\xca\x90yG\xf4c(i\x11\xd1\xe7\
+\xbe,S\x8964`\xe6c\xae\x18Q\xe1@\xc6\x86v\xecr\t\xe1\xa3\xedE\xd0F\xf0@\xear\
+\xa3\x1f\x07!5\xe4&]n\x9f\x14\x94)\x7f\x8b\xfbU\xfa\x8d\xb3,O\xa2\x8cOy\xcb\
+\xe2\x0f\x80\xe6S\x0f\x90\xc4\x8d\xd2Y\xfad, \xc1\xe9\xe37\x00\xfeUb\xce\x87\
+\xe9\xd3\xfd\xce\x1b;\x1f\xf3\x1c\xb4Q\xe0t8%\x92%\xc2t\xe4@\x80\x00\x92\td\
+\xeciKK\x10\x06 \x91\n<\xec\x1d\xac\r\xe8\xde\xb7Fjf\xf4\xf1\xd9i@\xb6y\xb9\
+\x11;\x01z\xd8P,\xa5\x84i\xab>\xa16F\xb1\xd3&\x9a\xb1\x1a\xba\xcd`\xc8\xd3c/\
+{\xd7\x85iC\x1b3T\xa6\x82\xb8\x8d\x19}\x86c\x87o\x82\xb6\x0c\x1dbz\xe0"7\xd2\
+n\xac\x8b\xdc\xb4eP\xc7\x82\x81\x8d\xba\xe13g\xde\xe7\x8eN\x01\x00u\xbb\x91\
+\xaf!\xdd\xe7n#\x97\xe7\xf3\x18\x04\xf9\xdd\xec>u\xc1d^\xd1K\xa4\x87\xbb\x83\
+\xeboY\xfe\x02@\xbc\xc2J\xaf\xa1\xfaR\xc2`Xx\x0e\xe2\x8dG\xd6k \xd7aU\x86\
+\xce3\xc0\x13K\xe9\xb8\x0c\x9a\xbeG(n\xfb\xc2\'\xa85\x0b\x11J\x195\x1b\xfa\
+\x01\x1a\x9d\x81\xfb\x07\xac\xb9h\x93\x82\x92\xdd\x9dD\xa2\x90xO\xe03uE\xca[\
+\xd5!%\xe7\x0e6\xb4)\\\x1b\xba\xc5S\x01\x10;9\x90\xbd\xab\x81\x06\x0c\xa5,i\
+\xe0I\xc4<E\xae\xbf\xf6\x01ox<\xe0\x94\x96\xe9^\xcb\xef2f\x0cm\x03/8=\x01\
+\xc0k\xab\x04\xd7\x86\xba\xef\x13\x1di+ej}\x86\xa6|\xa5\x00\xac\xaf/\x98\x96\
+\xcc3\xec\xba\xef)\x98\xeb\xdf\\g<\x04\xc1\xef5R\x93H\xe8\xee\xe2\x90\xff\
+\xa6Q.%m\xc4\xb3\xa1>\xfcl\xc2C\x962\xa66\xf0\xe5\xa6l(u>\xc9\xcbX\x88\xbd\
+\x0f\xe6):\x1a\xb5e\xec\x13\xc3W\xd8\xd0\xc2$\xb1\xd4\xfbhgj]\x86\xe6\x12\
+\xc1R_\x1ef\xf7Rz\xba\xf7g\xf6\x84\x8fOi\xb2oT\x11w\xc8XH\xae"K+\x9aL\x1b\
+\xc9\xdc\x9f\xdc\x01ez\xc3\xe3\xf1\x13\xb0?\xfb\\m\xa4\xd2`\x86H\x12\xcb\x06\
+\x8f#\x8d\x99J\xe8\x92\x04:pb&\x9f\r\x88z\x0c\xcd%\x82E\x1a\x14\x9f\x9a\xe4q\
+\xb0,w\xbf\xa3\x8b\xcb\xd4\xf3\xca\xb7\x0eL\x15J\x83\x19g\'\xb1V\xcc\xf4\xa1\
+\x8c\xa9\xf5\x18\xca\\\x89}5h\xcc\xb1\xa1\xbe.\x8f\xc7\x0f,\xcb\xfa\xa7X\x9a\
+hu\x0coCSp\x15\x8c1\xb31\xa2]\xf5\xcd\x98Zq\xdaB\x0bO\x1d\xe9\x95p1\x9d\x834\
+mI\x05\x08V\xbd\\\xe7\x03u\xe5\x9b\x0c\x84RIG\xd8\xe9c\xdaw\x1c\x11\xda\x05\
+\xe5\xb2N\xae>7\xdb\r\xa5\x9es>u8\x8d\xf7\xb5\xbbY\xef\xe5\xba\xb8\xddv|J\
+\xb4\x16\x98\xb1U/\x00X\xce\x8f\xe2ArA|\x85\xeb\x8f\x83\x8cs\xbe\x04\xa8Gi\
+\xf0\xba\xaa\x18>\xeb\x99\xe2\x11\x93\xcf\x0b\xb2?\x1e\xe1\x80\xad\x1eS\xbf)\
+|F\x00\xd59_*\x1b\xe0\x1e\xe9,}l(\xd4\xb8\x96\xd8\x8dl\x7f.\x1adO\xb1\xe3<\
+\xe2=\xbf\xa3SoW\xde\x87\xabW\xe2\x9a\x1a\x86\xd6\xb0\xa1>\xee\x90\xce\xa2\
+\x86\xa1\'O\x910C\xb3\xbe\xdf\xacW\xcc\x18\xcaFM\x1b\x1a+\x0b`\xbc y\xa7Q.\
+\x88_;G[\xfe\xc8\xf4\x04\x91\xb2\xe3\xbe\xdf\xb7HOp\xe5\x9a\x1a\x86\xb6\xb0\
+\xa1>Fdj=_nO\x1b\xeaV\xaa\xa0\r\xc5\xae%\xa74fC\xcb\xd1\xd2\x86\xc6\xca\x06\
+\x88l3\xd7\x10j<E\xb1D\xeb@\'\x00\x99\xa8\x86[\xb6\xe3Q:MiX~XQOQ\xe3.\xb7\
+\x82\x83\x9b\x92\x97Kv\xce\x97\x82\x9b\xa9\xe8\xeb&\xa0\xd78)(\x1a\x80T|\xeb\
+t\x96\xee\x01n10\xf2r\xa5\xbb\\\x1fh\x86~\xb6\x8ee\xf4\xea\xc4\xd0\xfe\x13\
+\xf0\x9a\x88-\xd5h\xc1\xd4\x8e\xd3\x16\xd9\xe2H6\x14\xd3\x0b@\xce\x86":\x01\
+\x103\xf4\xa5\xf4\xbaSz\x059m\xa4\xb7.\x88^\xad\x0e\xf7i\xb2OQ|\x92]\xa7\xd8\
+\xf4\xfb\xf0l\x95\x9f\xc4\x06\xc0\xdf\x8a\'\x94\xf9F\xb6\xaa\x13\x9d\xb6\x98\
+c!\x8a)\\\x01\'\xb1\x91V-\xa7C\xe5\x15\xdc97\x9ad\xb9\x84$1\x80\xa66\xd4\xc7\
+\xb1\xcd\xab{*\xaf\xb4^_mC\xb74M\xea}w\xa8\xab\xbe{,t\xb4\xa1k\xf7\xb7\xfe\
+\xe5\x93\xf8\x95\xef5p\xfb\'\x01\xb3\xa1\'\xb0l\xe8Vq\xc1\xfaP\xe2\xca\xef\
+\x11\x02\xd91\xdcj\x17\x94\x14h\xcey8<J\xeb3\xfe`\xe5\x0f\xc4\xea\xe2t\xd0]\
+\x95\xdeE\x86\xa1\xf5\x8f\xca:\xb2\xd1\xbd2\xc4\xbfr\xf7\xa5#\xb2\xa7L\xc5\
+\xb8\x83\xb7\xa4\xfcD\x19W\x10\xad#zY\xb7\xdcI\x0c\x83\xbf\x93X\x80\x083\xf7\
+\x7f\x1f\xbf\x01\x00\xab\x0f<1\xec\xba\xde\xae~\x12\xa3\xdc6\x87\xd9\xb9_^5\
+\xa6\xfeu~\x9fe\x9e\xec\x9fS\xee\x03>\x19\x07\x07",]7\xb0\xf2\xbbr\xc1zs\x1b\
+-U_\x194\xdas\x9e\x90J!\x19\x8b\xf4\xd6\x9f\x02D\x96\xfa;i$\xd4\xc8\x08\xd9g\
+\xcc\xc6]l\xe8\x8e\x143EX\x1a\xda\xd0\x143\xddc%\xc3#.S\xfa|\x18\xbd,\xc2^)\
+\x01\x1b\xda\xf0T\x88:\xe9\x1f;\x02\xe6 \xe7\x9c\x9dYuf\x84\x9f\xec\x15\xed1\
+\xbc\xac\x84u\x03\xc9K\xaa\x1fr%z\xafv\r\xda!\xfd\x03 \x11d\xc6\xc2{\xae\xdf\
+\x96\xb0\xc9\xd5!_dpt\xb7\x007\xe1\xc8\xe5\x9ae\xb3?\xda\x94>\x03\x1f\x9f\
+\xd5\xf8\xa8\xacL\xae\xea\x85n7v\x96v|\xf0\x12\xa6\xc8\xe0\x03\xa7H\x81N\x97\
+>\xcf\xf3\xf5nWe\x92\x984K\x93\xcc\x0c?\x1e\xea&W\xbb\xec\x1d\xcf\xe78\xfb\
+\x1au8\x106\x97\x01^\xc8\xd2\xa2\x14J<\xbcwrR\x10\xa60\xf4\xf22\xba\xdc\xca\
+\x86\x92!0\x85!\xdb\xcc|E\xf9K\xf2]\xf4;\x8c>\x8e>G6WH \xdbSE\xd8\xd3\x08,x\
+\xe0\xd9\xd3\x94L?\x11\xacx\xc0d\xbb\xa0T\x86\x9fz\x92r~\x9c\xa6;}\xeb\xb2\
+\xcdA<\x01RI\xd8\xd0$\x1d$\xd0\x05c\xc7\xc9\xcfK\xac\xa3b\xdd-\xc0]\x1fN |\
+\x9d\x9a\xe0,EW\x9fu\n\x82wb\xe8\x8e6\xa15\xb2\x1eA\xd9\x9f\xbf\xafS\x13\\\
+\x9f\xfd(\x913\x98uj6\xb4\r\xc2HL>M\xa5\xe7\x8ec\x9d\x19\n\xd0$\xb4F\xd5\x03\
+);\x9c\x00\xa4\xea\xea3\xc5Y\x96\xbf\xcci\x8d\xd9\xd0f\x08#1\xf1\x14\x97p\
+\xba\xd3\xd6\x96\xf6\x99\x87\xfa\xc8Eb\x00\xfa\xd8Rdn\nP+\x12c\x0cm\x0b\xc6\
+\xbc\xf4\xc4\xe8\xc6\x0c\x1d\xc0\x86\xee\xc8DbZ\xd8\xd2\x84\x07\x8b\x93$v$p?\
+\x9f0S\x13\xb3m\x94\xdb\x01\xce\xbc\x94\xe5=j\xc8\xd4\x81\x18\xbac\x00/R,9\
+\x1c\x08\xe9\xa2\xde}\xc7\xefl\x1d\x9b\r\xed\x02\xf4\xf0\xf6\xad\x01\xa6\xe9\
+\xbd\xeen\x8e\x06\xd9\xdb\xd4\xf1\x80\x0c\x05\xc8/C\x84\xcaL\x8d{\xb0\xfc\
+\x13\x9c\x0e\xf6m\xd1\x9ex^Sf&q\xbb$1\x0er+\xbf\x8f\x7f7\xc8\xf8\xc7\xca\x06\
+b\x16>+\xa4\xa66\xc0\r\xf4/\xb2j\xdaG\xa2\x12\t\x03\x9c\xe3\x98\xaf\xc6\tec2\
+tG\xac\x1b\xda\xff-\x90\\\x96F\xa6l\x7f$\xbb\xab\\\xd2\x88*\x93\xc4|tgj\xe6C\
+y\xfd\xc0<\xcf\'6\xd6Y\x0cL\xc7\xd8\x0c\xdd\x91\xfaz\x01\xea2\x95T\xb6D\xb9\
+\x9am\xa8\x0f\x16S\x85\'\xf0\xd4\x01M\xea\xda\x04\x1f\xdd\xdc\xdf\xfb\xbf\
+\xb3:\xd3\x9f\xbb\x07CwP6U\xae\xe5\xcc\'m\xe8\xec2\x89\xe0\xca\x0ct\xberm\
+\xfdm\x8e\x05e8;\x16Ze\x7fK-\x1b 1\xe0bY~\xb9{y"\xac\x8a\xe9\\~\xcd\x18\xaa\
+\x0c+C\'\xfa(\xaa*\xd8l*`\x87T"\xb4 \xab$\xd9n\x0cU\x86\xb1\x18\x8a\x813m\
+\xe0\xb0#%7\xbb\xb7\xd2\x85k\xa9\xa30I\xf3P\xb3\xa1_\x85\x0fC\xfd/\x96\xb2\
+\x82\xd9\xbf\xe7\x85\xfc\x8d\xf2\x1c\x05W\xd28\xf6\x7f\xc7\xae\x1d\x0c \x04\
+\xd7\xd9\xd7\xa8\xbd\xdf\x05O\x913\xfa6\x86*C\x18\xe0\xe6\xec-\x801\xb4DN\
+\xee~\xca\xf3\x01\xc6\x9a\x1f\x92X\xc6\x1d\x99#\xe9\xaf\xc6Pe\xa0\x8drs_H\
+\xea\xbe\xda\xde\'N6\x80\xc4\xfc\x90\xc2\x96\xa2\xb90\xc7\x86\xc6\xdf\xc7\
+\x18\xaa\x0cc2\xb4D\x0e\'\xc4&bC\x99\xf21\x99\xfe\x98#\xcb\xe8\xfc(|e(g;\x97\
+\xda\xc8M\xf8K\x9f\xc5d\x89\xb9\xe4<B\x90\xd6\xeap\xc2mo\\&"\x7f\x9c\x007%\
+\xa1*w\xcf\x11\x04&\x96\'\x96\xe1\xf0\xe3\x94\xfd\x93\xb9\x17y\x8e\x12\xe0&\
+\xe27\xa3\xf4q\x90s`\xb0\xf0n4mI\\\x13t1\x86\x0c\xad\x99\xe4\x94b\x18\xb7\
+\x81r\xb2X\xf2\xde\xb4\x1e\xe2\x0683\xf4\xe5\xfd\x1f\xe0:\x13nWIu\x98\x93\
+\xbc&\xc8\xf6|\x97\xcb\x19\xa4P\x1b/\xd6eN\x0c\x19~\x991y\x1c\xbdNpG\x97o\
+\xb8\xcb\x11\x99\xf7\xb4\xa1]\xb07p\xa1\x93"u\xcd\x02\xdc\x86\x18\xae\xad>+\
+\xedrc\xcf\x97\xca\xa1\xc8ma\xcbK\x03\xe3\x82l7\x86*C_\x86\xc6\xe4\\\x91\x95\
+\x92)!wp\x18C\x95a\x0c\x86b\xb2\xae\xca\x8b\xc9\x94\x90;0\x8c\xa1\xca06C\xaf\
+\xca\xac)wP\x18C\x95a\x1c\x86b\xf2F\x97; \x8c\xa1\xca0\x16C1\x995\xe5J\xc9\
+\x1e\x08\xc6Pe\xf8\x1e\x86\xd6\x96=\x08\xc6\xc9)JA*\xdd\xa4G\xdepc\x8c\xd7\
+\xa0\xca\x18\xd3\x1a\xe35h\x0c5\x99\xa4\x88\xa5c6h\xedD5\xc5\x18\xb3A{0F\tK\
+\xc7lP\xe5,\xaa\x891\x1b\xb46\x14\x7f0\xe6XP\x86\xf1\x1c\x0b1\xd9w\x93\xdf\t\
+\xc6Pe\x18\x97\xa1\x98|\xc92\x8c\xa1\x86;\xc0\x18ZCvG\x18C\x95\xc1\x18ZCvG\
+\x18C\x95a\xfc\xdd8[B\x01C\xd7\x06}\xddc1\xab!\x0fc\xa8\x0b\x05\x0c\xfdN\xe7\
+|\x0c\nBh[\x97[\xf8\xb4\x8dr\x87\x831\xd4\x85\x02\x86\xde\xabAk3\xc8\x18Z\
+\x11\n\xd8\xd2\x03\xe36\xa8\xa1\x08\xd6\xa0\xca`\xae?e\x18\xd79\xdfz\xca")\
+\xbf#\x8c\xa1\xca`\x0c\x95\x96\xdd\x19\xc6Pe\x18\x93\xa15m\x9cbv\x02\x18C\
+\xd5\xe1>\x0c\xad%[\x11;\x01\x8c\xa1\xea0\x1eCmt{\t\xc6Pe\xf8\x1e\x86*\xf6\
+\x0e\xb90\x86*\xc3X\x0cm\xc9Ne\xcc\xdc1N\xf8\xacV@\xfb\xcb\x02\xe5\xe34(\x86\
+Z\xbbp*\xc6\xd8\rZ\x0bJ\xbb[\x80Q\x1a\xd4\xf6\x9b\x17\xc3\x18\rj\x10C\xff\
+\x06\xada\xe7Fd\xe7~\xf0\xeb\xe9\xe0\xd8\x9f\xf0wp\x8d\x87\xbe\x87\xd9\xd5\
+\xa8\xf8a\x1a\xd3;\x16\xeb\x05\x02\x87\xd9\xe5\xa7\x97\xe6XP\x86\xcf\xea\xb3\
+\x92/\xf8\x8acA\x9aI\xa9\xee\xa9*;\x079\x10v{Gc\xa82\x9c\xd7\x87^=.\x92\xfa\
+\xbc$;\x9b3\x93z \xec\xfb\xfc\xcc\xe9\x1a\xac\xd7\x83\xe3)\x1d\xf9\xe0\\\xc3\
+\x8e\xd0\xb6\x03a\xbf\x03\xe3\xac\xe0\x96\xb0\xbf%\xb2(eQl!:\x02\xc5X\xec1\
+\xd7gm\xecZt\x9cs\xd6\xc5\x18\xaa\x0cc0tHv\x96\x8cV==\x83\xe7"e\xc4X\xee\xcb\
+\xc0\x9e\xf7\xf42\x86*\x03\x9d\xa1\x943O\xb0\xd1\x18\x17\xa5g\xabH2\x13 2\
+\x92\x8d<\x120)g;\xbd\xe7r\x0c>d@\xa2\x97X\x7f\x1bC\x95\xa1\x1eC\xb1\xeb\x92\
+\x10\x9fcF\x18\xc0\xb5\xef\xcd=E\xe7\xb63\x86*\x03\x9e$F\xf5\xe4\xc4\x18\xca\
+\xf1\xdepX\\\xc3\xf3\x83\xb2\x8a9\xeaGmhLF\xc1\x88\xd9/\xcb}\xce\xbboe\xe8<\
+\xd3\x074\xa9\xfb^\x8cgs\xe5\xe4\x9e\x15A\xda\xd1\xcd\x92S\xd4Ug\xa6-\xb1g\
+\x0e=\xc3\xe7>\xf1Pj\xe5\xa6\xee\xcb\xc9(\xb1\xa9\xb5"%SD\xb6DyU\xa3;o8\x1au\
+\x87\xf3.\x1f\x86\x8e\x86\xea\x01\xe9RVyp\xbb@\x00\x9e\x9c\xec\xb4\x85\xfa\
+\xdc\xa7\x8b\xef\x9f\x82\xe2\xe3\x05m\x1a\x13+\xb7\x9b\x1c&b>]\x18\x89\xa1\
+\xcdRD\xa8\x8eu\x02\xb2\xae9\xa2.\xc5z\x84\x8e\x8f\xf3n\x9c\xad\x12\x93\x87J\
+\xa5\x1c \xd2T\x0c\xdf\x9e\x1e\xbe\\\x8f\xa1\xb5\x1a\xb6wC^\xb1w(\x84\xa6;\
+\xa5\t\x06\xae\x0c\x00\x0bpk\xc4\xb5\xd5gw\xc2e{\xe7B\xca\x0e_\xb5\xa1\xa1.\
+\xc6Pe\xf8\x0e\x86J\xb8\xf7\x0ePSCJ\xf4*\x94\x03fC\xd5\xe2\x0b\x18\x9a\xf6}\
+\xb2Q\x93\xed\x02z\x19C\x95\xe1\x0b\x19z\xf1]\xc5\xec\xde\xa6\x9b1\xd4\x90\
+\x82r\x86\nET0\x99\x83\xb2\xdd\x18\xaa\x0c\xba\x19*\xea\x1d\x82l\xfa\x07\x1f\
+\x826t\x93g\x0cU\x06\xdd\x0c\xbd\x1a\r\xc1\xe4\x01\x0cjCWyx\xf8L\x0b\xbe\xae\
+\xcb\x1d1\x05E\n\xe2;\x85"\xe9&\x03B1C\x89\xebR\xa8`\xe5\xde2eJ\xe9\x08\x9a\
+\x19Z\x1dc\x8e;\xf42\x14M7a\xae!\xe1\xaeQ)\xbd&\xb1\x0b\xcav\xcd\x18\xaa\x0c\
+\xd6\xa0\xca`\x8e\x05eP\xecX\xa8=\xca\xbd(\xcf\x95)8\xca5\x86*\x83^\x86\xfa\
+\xa3\\\t\xb7_\xd5P\x1c\x80D;\x18C\x95\xe17\x00\xc0\xd4{\x9f"\x83\x18\xfe\x07\
+\xd2\x8b\x12\xe7\xc3\x8c\xd4\xb6\x00\x00\x00\x00IEND\xaeB`\x82' 
+
+def getWizTest1Bitmap():
+    return wxBitmapFromImage(getWizTest1Image())
+
+def getWizTest1Image():
+    stream = cStringIO.StringIO(getWizTest1Data())
+    return wxImageFromStream(stream)
+
+#----------------------------------------------------------------------
+def getWizTest2Data():
+    return \
+'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00t\x00\x00\x01\x04\x08\x06\
+\x00\x00\x00\xf9\xcf\x10R\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
+\x00\x10\xb4IDATx\x9c\xed]M\xb2\xb4*\x0c\x8d\xaf\xbeM\xd9\xc3\xbb-{ho\xab\
+\x87\xf6\xb2|\x03\xc5\x06\x0c\x100\xfc\x98\xe6Tu\x95\xf7\x82\x01\xc1C \x89\
+\x00\xcb\xb2\xac\x1d\xd7\x00\xf3\xbc\x02\xac\xdb\xcf\xbe\xa6\xa4a\xf9R\xd3z\
+\x87\xa6\x81\xb5\x13b_\x00O\xda\x7f\xd0A\xc20\x00\x0c\xaf\xd7\xf6\x1bj\xd7\
+\xc6\x83\xceP?J\xb0\x8a\x93\xed\x9d\xa1\x16\x86Acc\xcbLt\xa13\xf4\x8b\xac\
+\x93\x95B:tX\x96e}<\xc6\xda\xefU\x07\x13\xfe\x038\xfa\xf9\xa7~\x00\x000\xbf\
+\xb6\x9f}\xad\xfe\x06$_ \xcd)\xdfw\x1f\x96/!m]\x01:C\x85\xe1\xa7\x18z\xe0"s\
+\xa2\x98\xef\x91I\xbaO\xcbG\xa9sg\xa80\x88g\xe8%]\xa5]G\xb1\x1f\x93\xaf\xa59\
+\xeb\xe9\xa8\x973/"\xbf3T\x18\xc42\xf4\x00\x13C\xa3\xd8\x85\xc9\x0f\xb4s\x0c\
+C\x8f\xe7\xeb\x0c\x95\x0fQ\x0cM];\x96X\x1f\x92F\x94\x08\x9d\xeb\xba\xaf3T\
+\x18n\xcfP\x00Hb\x8eW\x9e\xca\x8b\xc9\x88L\xbb<\xba\x10e\xa8\xbc\x9d\xa1\xc2\
+p[\x86\x02@\x14s\x92\xcb\xc9\xac_\xd9\xf5\xfe\x1d\xddg\x00k\x94{\xeary\xdd\
+\xc1\x9d\x0f.\xa7\xf3\x0c\x000\xbf`\xf9\xfb\xdb\xaea\x7f\xcci\xba\\\xe6:M,r\
+\x8a\xe0N\x0c\xf5\xbe\xa1\xf3\xbc.\xcb\xf2\xfd\x1f\x033\xc9e_Mcd\xfbm\x18\
+\x1a\x1b\x0er\x1bFq\xe3\x0e\x0c\xa5\xbc\xa1\x8a\x9d\xcb\xb2\xac\xdc\xcfDa\
+\x87Q\xcf\x8a:\xf4_\xed\x17*\x84\xda\x81Z\xc3\x00p(e\x07\xd4h\xb0\xcd\xbe\'\
+\x80cp\xd8.\x86g\xa6\xca\xa9\xb2\xf5\xf2Zg(\xf9\r\xb5t(k\xf9\x81\xb2\x93\xe4\
+&\xe8I\n\xc4\x18\x16\x96\xe5\x03\x8f\xf7\x1b\x96\xbf?\x00\x00\x90\xf0L)h\xd6\
+\xb0\x00\x00Q\xceb\x1blu\xf0\x94\xcd\xd9vWM\x7f\xea\'\x86\xa1j\r\xfax\xbf\
+\xb7\xbf\x9f\xbf9\xcbm\x86\xa1\xf3\xfe&\x02\x00\xc9\x8c\xe6d\xd3\x8e\xablY\
+\x96O\xd0\x84\x97eD\x8at\x9f\x9d\xe4,\xcbR\xbd;\xd5R\xc3\x98\x04$\xc8\xd0\
+\x97-W\xebsL\xb2*\xb7M\xec\xaf:C\x8d7\x12\xc0\xa9\xab\\\xcc<\xe400\xf4`\xa6\
+\r&C?\xb9\x1dn\xafC\xf7\xca\x1f3\xd4\xf7;^\x072\xe8P5SVuI\xaaGeTg\xe8\xba\
+\x02\xac\xd3t4\xa0\xbe\xf4\x88q\x16\xab\xfb\x97\xbf?X\xfe\xfe\x92\x18\xa2\
+\xdfot&\xc11\xde\nC\xff\x01\xd4\xb7\xc6l\x18\x01\xe6\xf7\xf1\xd7\xc6\x16-\
+\xf99y-.\xcbb\xfeM~\xa6\x9d\xd9:\xb6\x11K\x1b\xb54\x96\xe6k+m$x\x9a\xd71\x96\
+\xa6\x7f\x00\xb8\x0e*\x89\xe1\xb5\xbf\x8d\xcf\xe9<\xec)f\x04\x8c\xed\xc3\xeb\
+m\x0c\xb9\xebJS#\x9f\xcf\x9fi\x90x\xbf\xb7\x17\xeb9}Y\xa215\x97\xd1\x7f31\
+\x9e\xcb\x83\xe7\x14\xd5?\x8d0\xf4\xdbH\x8f\x87\xc9T\x85`\x1d-{k8\x7f\x1c3\
+\xd5\xdf9\xed\xb2Xy\x00q\xfdSU\x87\x02\x00\xae;\x9e\xd3I\'r\xebP[go\xcc\xbc\
+\x1e\xecU[\x87\xb61\xcbuAcQh\xf6J\xb6\xe5F\xc8\xbc#\xaa\xe9P]o\xa2\xba\x036\
+\xbd\xa9\xf2\x1d\x9d\xe0\xd0cT\x1d\xaat\xa6\x929\x8e#\x0c\xf0:\x95m\xd7+w\
+\x1bq\xe9\xd0j\xee\xb3c\x90\xf0\xb8\x8f\x14t\xb7\x98\xab\xbe\x14\x07\xb7.C\
+\xe5?\xea\xc2\xe0\xba\xba\x02\x9f\x9b.\x06UBP\x0evz\xa0\xbf\x95\xe3h\xb2\xed\
+\xf3\xf9\x90d\xe8\xe5}>\xa6\x05h\x1cGc\x04\xf0\xd6\xe5N\xe1,5\x18\x8a\xbd\
+\x85\x14F\xd8L\xd5\xf3\xcd\xda\xfff\xeb\xfe\x93\x9dWK\xf7\x8e\x12\x19\x82\
+\xcd\\\xf0\x8d\x121(\x1e\x82B\x99\x82\xbb\x181\x8e#\xc0\xae\xff\xde\xef\xb7\
+\x91oRa \xe3Yw\xbe\xdf\xdfe\xd08\x8eh\x9e\xd8\xba4\x8b\xd2\x0c\xe5\xd0U6\x03\
+\xa9\xf7`\xf2C\xe1\x95\xa5pK\x1d\xcae\xc0\x98\x12X3!\xc1\xd21z\xf86(\xc9\xd0\
+\\\x01W\xc9\xf5\t\xcc\xb4\x8b\xd7\x85a\x94h\xdb\xb0\xd0\x11\x8d\xac\x86\x05\
+\xdd(\xa0/\xe6\x01\xe0\xecw\x8cH\xc3&*\xaf\xd7\x0b\x9e{>5\t\xb2\x87f\xb5t\
+\xc1d^\xa9\x97\xbd\xacJ\xc1\xf0r\x1b7b&fY\x8d\xf3\xcb\xe2o\xb0\xd44\xb4\xbe\
+\xf3\xb9\xa1O\xf9\xe6\xb8\x17\x87\\/\x96\x11\x8e\xc7}\x96\xd58\xaf/\x178\x81\
+\x1a\xb7\x11\xa8@/\x95\'\x10\x00\xcfZ\x9fh\xe3<\x00K\x90\x98\x18\x1dz2\xce\
+\xeb\xec\x13\xf0|T\x14q\x9f\x85\x02\xa6\xd9\xdep\x07l\xa6\xa2\x8c(\x10f\x92\
+\xd4F\xa2\xdcg1\xd0\x83\xc4\xf6\xc8\x07\x00DO\nr\x95a\xc8\xceP\x00`g\xe8\x8c\
+\xdc\xa3;\xb8\xd7u3\xf1\xd9A_*\r\xadKgh\x05X\xce\xe9\x19\x00\x9e;\xe3t\x1d\
+\xaa?\x8f\xce\xd4Ka\xa27A~\x86F~\xd2\xe0\xfb\xd9a#O\xad\xeez(\x89~\x8f\xceT#\
+L\xb4b\xb8\x89w$\xfb\x89Y.%l\xc4\xd2\xa16\xech\xc2C\x960\xa6V\xd5\xa1\xa9\
+\xcc\\\xa7\xc9\x99\xc7\x15 6\x8e\xa3\xa1OOLM\x181\xb2\x8cdV\x1b\xc9\xd2\xa1\
+\x89Ab\xbe\xe7\x91\xce\xd4"\xb6\xdc\x94\xa0\xe5\xe1e~\xabr\xd8L\x1d\xb7\xe8A\
+b\xbe \xeba\x18\x8f({;\xa0\xbb\xa63\xfb\x16Ab\xc7@\x90\xe0\x9e\xf2\x85\x8d\
+\x84\xf2{\xebd\xed\xc9@\xbd/7\x9awp\x87\x9c\xc7\xae\xb7\xce\x17\xd0\xc5\nd\
+\x88\x8d\r>k\x12\xb9\xdeL\xecM\xc3B4m\xf8\x02\xc1\xbc\xe5\x11\xf3c\xf5\xa2\
+\x84\x89\xe6\x06\xd6F)\x0e\xeefv\x12+\xc6L\x1b\xd2\x98\x9a\x8d\xa1\x9e@0\x8c\
+EWY\x12\xadC-F\x18\xdb\x02D\x8e\x0e\x1ch^\x87\xfa\xa0\xb3\xce\xc5\xcc\xd28\
+\x96E\x16n\xc7\xd4\x1a:T\x87\n\xaf\xbc\xaa\xbf(\xacB\x19`\xe9*{\xe6[\x8a\xa9\
+\\:\xb4\x89]P\xf4\xa8\xf7T\x19\xac;\x97 \x13\xa5\xdamD\xfde3\xfd\xc5\x18\xbf\
+\xa7i:&@\xc9\xe5i\xf0\xd6\x89bbC&b\x98\x93<k{\x894\xfd\xc5 `\x9cO\x01\xea$o\
+\xbc\xad\xf21\x14\xa0\xa8\x03YG0\x0f\xd1\xc9\x8eM\xcer1\xd5U\xaf\xd8\xf6\x12\
+\xc3P\xaaq>U6\xc0=\xc2Y\xaa\xe8\xd0,i:<\xfa(*m\x87kIs\xdcs\xf5yb\xeb\xe5I\
+\x13\xc3\xd0\x1c:\xd4\xc6\x1d\xc2Y\xc40Twps3T\xa5=\x1e\xf1\xe1,\x9d\xa1\x89\
+\xc8\xa9C]e\x01\xb4\xe7$\xaf2\xcb\xcd\x91f\xec7\xe4\xba\x0f\x93\xe1Ks\x94\
+\xfdx\xd0\xc2Y\xc82c\xeb\xe5I\x13\xc3\xd0\x12:\xd4F\x8bL\xed:\xf4\x02s\x92\
+\x98\xcaQ\xaf\xaeC\xcb\x94\r`~\x9aX\x83\xa9b,E\xae@\xebS\x9d\xecz\xa9\xbf/\
+\xd4\xcb\x0e\x11\xa5\xeeO\xe8m\xaf\xc4zUqp\xe7\x00\xc5\xc1\x8d\xba\xa7\x12\
+\x1d\xc9.\xf9\xa9\x8e\xfa[;\xb8\xa5\x02\xf3\xd2\x14\x0fg\xa9\xed\xe0f+/5HL\
+\x1bA\xb8\x80\x85\xb3\x84\xc0U\xaf:{\xfdU\xdfp9/0/M1\xa6\xb6\x12$v\x15W\x83\
+\xc4r\xd5\x89\x1ax\xc6U\xaf&BPX~\x0ca,9\xebU\xeap\x9ff\xbfm\x89/\xeb{\xed{\
+\x9e\xd8oH\xd4\xfeG\x00\xe9[\xf1\xd8\x98\xe7\xd7i\x0f%\xaeo[\xbaa!\x84\xf9\
+\xfc\x05\x1c\xc7FZ\xb9\x8c\x0eY\xbf\x0f\xd5\x1b\xc5\xb8\xce``\xd0\xe1\xcd\
+\xe71\xa3\x85\xe4^\x85\xda\xb7\t\x0b\x86\x8b\xad\x97\xf3\xf9~Z\x87\xda\xcb\
+\x84@\xbe;\xb4U\xd5=\x16X\xcb\xd1\x10\xcc7\x9b\x87\xd6\x1dGK:\xee\xd5\x81\
+\xed\xc0\xc2V\x7f\x06\xd3\xdfo\xea\xd0\xbd\xa1\xec\x89\x0c\xf5\xcb\xef\x16\
+\x1c\xd9.\xdcj\x17\x14\xdf\x8fb\x9cW\xf5\xc1\\^\xdf\xe3A\xfc\xf2c\x8d\xee\
+\xa5\x19Z\xe0\xa8\xac\xfdmv\x1d\x03\xc5u\xf4\x94\xb63\xa3\xf3y\xe6\x80\xa5f~\
+\xc108\xd8\x17{\x14W\n\xeepT\x16\x00\x04\x9d\xc5\x1c\xe5\x84vAq1\xf3\xe4\xf2\
+r\xb4\x07\xe6\xc4fm\'\xa6Yn\x99\xc3\xec\xac\xfd_\xed4\x0e\x96\xea\xc7M\xda\
+\xcf\x83\x9e\xda\xfb\x9c\xe0\x81\xa59Yz>d\x8f\xb7\xddn\xb0_nP?$\xbe\x85\xd8\
+\xcf\xa5Ca~\x19iv\x98\x88\n#1\xf6Ar\x953M\xc1\x91\x80\xbd\x8d"\xfb\xa7\xdcq\
+\x93\x0e\xfd\xa0\xae/\xb3\x14\xd1\xa1>f\xea\xc7J\xdaG\\\xfa\xdaC\x1f\t>\x9f\
+\x0f\xafU\xea\x0e:\xd4x\x03\x01\xd8\xc3?\xd4\xef\xb4\xe3\xe6|>\x82Yg\x95]\
+\x17=\x9fo\xc4\xb0\xd9\xce\xb5.e\xb5\x14\x95@\x8d\xf0\x0f\x9f\x93\x19u\xefi\
+\xf7Q\xca\xe2\xfc\xba\xfb\xd4&Z\xbdbP\xcc\xc1\x1d>r9\x9f\xf3w\xdd?(\x8e\x81\
+\xaf>M\x1f\x9fU\xf4 \x1e\xcf[\x18\xfb&\xda\xc0\xf6E\xf09\xbc\xb1Q"f\x17\x14=\
+_\xca\xd1]\xa8<\x86\xd1\xab\xa9 1n\x96\xfa\x98i\xe8\xf5\x1d\xce\xcf\x06\x1d\
+\xb2\x15\xfe\xfe\xfe\xda\xd9-\xa5\xf8av\x8e\xb7\xf0j\xa0VJ\x08%6J\xe8rB28w \
+\xbb\x9d\x0e\xa5\x82c\tE\xd5\x99\x18Km\xd8{(\xe9\xa8\xb1\x9fR\x08\xc5\xcf\
+\x0f]W\xe4X(\xfb\x88(\xd7\x1e\xaa\x1e\xcc\xf0\xdd\x87>\xee\xc6\xd7)D\xe61\
+\x9b[\xbb\xce\xef\xb7\xf3DD#*\xe1\x8d\x1f\xe3\x15U\x0fu\xbd\xd7e\xbb\xa6\xcb\
+\x14\xe3>c\x87\x1dz\xe2s\x99\xe9y+\xb7e1\xc3\xc2\xc9\xc8\x10\xf8\x8a\xaax]\
+\xc0\xaa\x97\xd5\x81A\x19\x17\xeb\xeej\x87\xd8\xfe\xe9\x0c\xf5A\xb3"\xbd\xdf\
+\xef\xe3H\x11\x1b\xe8\xd7g\x95\x9c\xe0U\x18\x1ad\x87\xf6w\x95\x11C\xfd\xfd4\
+\x97&\xae\xfa`\x93\xa3\xe8:0\x99\xfe:C\x038\xb1\x8f\x10\xa6Rs\xc7\xb1\xaa\
+\x0c\xf5\xb2\x83\xd1\xb5F\xae\x07R\xb6ml \xc9\x80\xadsY\xda!\xb2\x7f:C\t\xb0\
+w\x12s\xeaG{\xb9\x03\xe0\xd4\xbb\xb9\x90\xf5S\x08*\x8cO&\x00\x90u\x18\x141\
+\x88\x9f>G8\x9c\xe0\x93\xb14\x19\x9d\xed5\x1d\xc7\x93\x00\xc0\xe1lO*\x1b\xe0\
+\xb7?\x85\xc8\x8e\x88u\xa9\xc1\xe8\xc2\x0c\xad\xaeC):D]g\xaf\x83\xa7\xec\x98\
+ 1=\x1f\xd5\x01\xdeg\xb95\xa0\xadK\xa3\xacG\x05\x99\xda\x0cC\x9dL\xad\xb06u\
+\x96\r\xe1pQ\xf5#\x07\x9e\x11F\xa8\xce\xd0\x8c@\x0fo\xdf\xd97\xcf\xdb\xb7\
+\xa4\xe8g\x84\x85\xda\xb89\x86\x1eo+@5+\x92\xafl,$T\xb1Zu&\x16\xc8M\x1e\x15\
+\xecgM\xd1\xa1\xad\xf9\xf5B_~\xab\xbf\x8d\xce\xe7\xae\x83k\x19\xb1#\xe6\x0bn\
+\xca\x92\x8bk\xd9\xd2\x9c\x83\x1b\x80\xd6\x00\x00\x99\x03\xcb|\x8dH\x98\xe0\
+\x1c\xa7\\\x94\x0e(\xab}\xcc\xa2\x0f\xce\xc0)0\xd3\xb2\x95\x1f*\x1b\tJK\r\
+\x18\xe3\n\x12+\x1e\xb1\x10\x83u\xa2E\xd4\x0f\xaf<\x87\xb9\xaek $\xe69\xc1{\
+\xde6\xc0X[Q[-3T\xc1\xf7\xf6\xe6f*\xa5l\x96r<#A\x0c\x9a\xd4\xa16bt*\xf7w:\
+\xe4\t\x8d\'mx\xbd\x8e\xba\x19\xd7\x03\xad\xceQ\xf7\xdd\x81\xa1\n\xa1\xdd\
+\xc9\xf4\xeb\x1ae\x1b\xf9\x03z\xdf7\xd2\xa4\xa4)t\xc3\x820\x18\xee\xb3R\xd1\
+\xdfW\'0G\x18\xa8c\xddv\\3\x94u*W\x95\xe7Y\x1fG\xa7a\xf9\x12\xd3:C\x85a[\xb6\
+\xcce\x98\x19B,\x9b\x8eIA\x04;R\x19\x1b\x0c\x0e\xbf\x92\xc6\xc8\xf6\xcePah\
+\x8a\xa1\x18\xa2\x96\r\x11\xec\xf0\xc9\xf5\xeah\xf5wb\x9a\xcb\xa4H\xb5\xe5\
+\x86\x9e\xb53T\x18\x0e\x86\xdao,\xe5\x0bf;\xcf:MI\xf7Q@b\xaa\xad\xe7\x00H\
+\xba\xed\x98\xe5;\x82\xc4\xae0\x94\xea)\xb9\xe2m\xd1g\xdf\x9d\xa1\xc2p\n\xe3\
+\x8c\xd9[\x00ch\x8a\x9cP~\xca\xfd\'y\t3\xe0S\x1a\xe3L\x96\xc4\xb2\xc8\x999\
+\x16\xfe\xda\x19*\x0c\xa4Yn\xf0\r\xf1\xe4\xcbm}\x8a\x8a\x06`X\x1f\x92\xd8\
+\x92\xb0\x16\x8e\xd1\xa1\xbe\xe7\xe9\x0c\x15\x86&\x19\x9a"\'*l\x85A\x87z\xdb\
+$a-L\xd1\xa1\x94Y\xf8\xc6\xd0\x88\xed\\r#\xb8\xe0O\xbc\x17\x95\xc5d\x92;\r\
+\x89\x84ouP\x83\x81g\xc8Ee"\xf2\x9bqpS\x02\xaaBy\x94\x13\x98\\\x1eS\xd4\xa0\
+\xed\x80\x8e\xbe\x8f\xe0\xe0\xa6\xa2\xe9\x98"\x17B\x06\x8c(Y+l\xfb\xe3f^\xb6\
+x\xd3\x18M\x8c\'\x86\xe6\x0c;\xf41,\xb6\x83B\xb2\xa2\xd6\xb5+m\x84\xb8\x03\
+\x0c\x86\xaa\x07\xa2\x1a\x08(\xb8[#}\xcd\x80y\x8c\xf3\xb9\xd9\x1e\x1crc&)\
+\xd4\xces\r\x99)\xe1\x98>\xfb\xb0\xfa_\xcaK\xb5u\xec~\xdft\x9f#2o\xa9Ck@up\
+\xb2\x91\xc2\x97\xd6\x1d\xdc\x1d.\\\xdac!u\xc8u\xdd\x9f*\x87"\xb7\xc8\x1e\r\
+\xa9\x8eqF\xb6w\x86\nCU\x86\xba\xe4\\\x91\xe5\x93\xc9!\xb7ut\x86\nC\x13\x0c\
+\xc5d]\x95\xe7\x92\xc9!\xb7et\x86\nC\xd3\x0c\xbd*3\xa7\xdcV\xd1\x19*\x0c\xcd\
+0\x14\x93\xd7\xba\xdc\x16\xd1\x19*\x0cM1\x14\x93\x99S.\x97\xec\x96\xd0\x19*\
+\x0c?\xc3\xd0\xdc\xb2[A31E>\xb0\x85\x9bT\x88\x1b.\x8d\xe6:T\x1acJ\xa3\xb9\
+\x0eu!\'\x93$\xb1\xb4\xc9\x0e\xcd\x1d\xa8&\x19Mvh\r\xc6Hai\x93\x1d*\x9dE9\
+\xd1d\x87\xe6\x86\xe4\x17\xa6\x1b\x16\x84\xa19\xc3\x82K\xf6\xdd\xe4\xd7Bg\
+\xa804\xcbPL>g\x19\x9d\xa1\x1d\xb7@gh\x06\xd95\xd1\x19*\x0c\x9d\xa1\x19d\xd7\
+Dg\xa804\xbf\x1bgIt\x86v4\x87\xceP\r\x12\x18\xfa\x93\xc6y\x17$\xb8\xd0\xb6Y.\
+\xd3g\x80}\x96[\x1f\x9d\xa1\x1a$0\xf4V\x1d\x9a\x9bA\x9d\xa1\x19!\x81-5\xd0l\
+\x87v\xa4\xa1w\xa80t\xc3\x8204k\x9c/\xbdd\xe1\x94_\x13\x9d\xa1\xc2\xd0\x19\
+\xca,\xbb6:C\x85\xa1I\x86\xe6\xd4q\x92\xd9\t\xd0\x19*\x0e\xb7ah.\xd9\x92\xd8\
+\t\xd0\x19*\x0e\xcd1\xb4\xcfn\xaf\xa13T\x18~\x86\xa1\x92\xadC::C\x85\xa1)\
+\x86\x96d\xa74f*4\xe3>\xcb\xe5\xd0\xfe5Gy3\x1d\x8a!\xd7.\x9c\x92\xd1t\x87\
+\xe6\x82\xd4\xe1\x16\xa0\x91\x0e\xed\xfb\xcd\xf3\xa1\x89\x0e\xed\xe0C\xf5\
+\x0e\xcd\xa1\xe7Zd\xa7:\xf8U?8V?\x10\xd6\x95\x16\x8b\xaa\x87\xd9\xe5h\xf8V:\
+\xf3|\x04\xf3\x94t\x98\xdd\x00\xdfk\xca\xf2\xb2\x1b\x16\x84\xe1\xf8\xfa,\xe5\
+\r\xbebX\xe0f\x92ox\xca\xc9\xce\xe3\\\xd1\xca\x07\xc2\x1e\xe7\xa8v\x86\xca\
+\x82\xf1}\xe8\xd5\xe3"\xa9\xf7s\xb2\xb343\xa9\x07\xc2\xea\xfa\xce`\xf1\x9eo]\
+\xcf\xc7S\xae\xd3t\xd6\xbd\xd6\xe8y<o?\x10\xf67\xd0\xcc\x17\xdc\x1c\xfa7E\
+\x16\xa9,\x82.\xc4f\xa0\x98~=1\xd7b\xad+\xcd5\xcf\xb1\x19\xdd\x19*\x0cM0\xb4\
+Ev\x9e\xd7\x91\x10\x9c\xad\x9et\x9du\x9f]7\x1fC1\x19\xe8\xfdV\xbd:C\x85\x81\
+\xccP\xca\x99\'\xe8l,\x12\xa9g\xab\xb02\x13\x00\x9d\xc9\xba\xca8\xb1\x11a4\
+\xaac\x91Y\xee\xa9.\xc4QB\xc9\xef\x0c\x15\x86l\x0c\xc5\xd29\xc1\xbe\xe3\x8a\
+\xc3\xe2\x13\xad\xdf\x0b[\x8aNz\xb73T\x16\xd0 1\xaa%\xc7\xc5\xd0\x18\xebM\
+\x0c\x8b\xb3X~\x10V\xc5\x06\xcda:\xd4%\x83j\xfb\xf5\xeak\xed\xbeS{.\xcb\xb2>\
+\xdeo\xf2\x84\xc6\x97o\x9d\xa6{u\xa6c\x02\x14m\x02\r\x98\xeb\x82\xf7y\x8c\
+\x13\x94:\xeb\xf7\x1d\xfePj\xe3\xfa\xf2\x85d\xa4\xe8\xd4\\\x9e\x92\xad.g\xd9\
+\x1c\xe5e=\xeak\xd5:u\xc7\xf0\xfa\xbe@U\x1d\xdc>dwH\xdbC\xdd\x15\x17\xe2\x0c\
+\xd6\xe4\x85(g\xb6\x86\xfb\xd4\xfb\x9e\xd3qk\xf5\x10\x14\x1b\xeb4e\xefL\xfb\
+\rW\xe5\xd6\x92\x13\x0b\xa7M\x174\x1dZ\x1b\xa5BD\xb0\xc5\xfa\xa5/\x078tob=\
+\xec\t\xd6:M\xe6n\x9c\xa5\x02\x93[\n\xa5L\xed\xcc\x16`\xeb\xd3a\xd8\x19:\x8e\
+\xe6:4W\xc7\xd6\xeeHc\xca\x0f\x90\xac7\x0fy\x16\xdb\x93\x97;\x89\x01\x06\x86\
+\x0c\x80\xee\xe0\x96\x88\xff\x006\xeaJ\xff\x19\xe6\xcd\xf9uM\xd6.C\x97yI\x0e\
+\x87\x8c]Ng\xa80\xfc\x04C\x0f\x16ho\xf2ev\xc2\xf7\x9a\xab^\x97\xea\xb4\xcb\
+\xe9\x0c\x15\x06\xf1\x0c=pQW\x95`;G\xbd:C\x85\xe1\xe7\x18zY\x1e\x93\xde\xeb\
+\x0c\xed A4C\x01\xc0\\/^d\x94\xcd\xaa\x16\xd9\xde\x19*\x0c\xb2\x19\xcah\x1d:\
+\xe4eb;G?\x00t\x1d*\x0e\xb2\x19\n\xc0\xb2^4\xe4)\x99\x1c\xf2\x18u\xe8!oY\x96\
+U*`\x9e\xbf\x8f;\xcf<\xf2\x94L\x0ey`\xd6\x91\x03\xcd\x85\xa0p\x81}\x1fB$\xdc\
+\xa4IHe\xa8\xceL6v\x82\xc9*6\x99Lu\\W\xc1\x0c\xcd\rC\xa7\xb6\x04\xb1\x0c\xd5\
+\xf5\x1d \x0c\xa3\xa4a\xf9r\xa4\xc5\xd6\xcb\x93\xd6\x19*\x0c\xbdC\x85\xa1\
+\x1b\x16\x84A\xaca\xe1\x00\xe7\xa2]\x93\xc9RGf\xc3\xc2\xbav\x86\x8a\x83\\\
+\x862\x84Y\x9e\x18\xdf\xb8q\xbe3T \xfe\x01\x00\xcc\r\xec$\xd6\xc1\x83\xff\
+\x01\xf6\x8dNq(hH\xc7\x00\x00\x00\x00IEND\xaeB`\x82' 
+
+def getWizTest2Bitmap():
+    return wxBitmapFromImage(getWizTest2Image())
+
+def getWizTest2Image():
+    stream = cStringIO.StringIO(getWizTest2Data())
+    return wxImageFromStream(stream)
+
diff --git a/wxPython/demo/wxWizard.py b/wxPython/demo/wxWizard.py
new file mode 100644
index 0000000000..97f47a75c1
--- /dev/null
+++ b/wxPython/demo/wxWizard.py
@@ -0,0 +1,115 @@
+
+from wxPython.wx import *
+from wxPython.wizard import *
+
+import images
+
+#----------------------------------------------------------------------
+
+class TitledPage(wxWizardPageSimple):
+    def __init__(self, parent, title):
+        wxWizardPageSimple.__init__(self, parent)
+        self.sizer = sizer = wxBoxSizer(wxVERTICAL)
+        self.SetSizer(sizer)
+
+        title = wxStaticText(self, -1, title)
+        title.SetFont(wxFont(18, wxSWISS, wxNORMAL, wxBOLD))
+        sizer.AddWindow(title, 0, wxALIGN_CENTRE|wxALL, 5)
+        sizer.AddWindow(wxStaticLine(self, -1), 0, wxEXPAND|wxALL, 5)
+
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wxPanel):
+    ID_wiz = wxNewId()
+
+    def __init__(self, parent, log):
+        self.log = log
+        wxPanel.__init__(self, parent, -1)
+
+        b = wxButton(self, -1, "Run Simple Wizard", pos=(50,50))
+        EVT_BUTTON(self, b.GetId(), self.OnRunSimpleWizard)
+
+        EVT_WIZARD_PAGE_CHANGED(self, self.ID_wiz, self.OnWizPageChanged)
+        EVT_WIZARD_PAGE_CHANGING(self, self.ID_wiz, self.OnWizPageChanging)
+        EVT_WIZARD_CANCEL(self, self.ID_wiz, self.OnWizCancel)
+
+
+    def OnWizPageChanged(self, evt):
+        if evt.GetDirection():
+            dir = "forward"
+        else:
+            dir = "backward"
+        self.log.write("OnWizPageChanged: %s, %s\n" % (dir, evt.GetPage()))
+
+    def OnWizPageChanging(self, evt):
+        if evt.GetDirection():
+            dir = "forward"
+        else:
+            dir = "backward"
+        self.log.write("OnWizPageChanging: %s, %s\n" % (dir, evt.GetPage()))
+
+    def OnWizCancel(self, evt):
+        pass
+
+
+    def OnRunSimpleWizard(self, evt):
+        # Create the wizard and the pages
+        wizard = wxWizard(self, self.ID_wiz, "Simple Wizard",
+                          images.getWizTest1Bitmap())
+        page1 = TitledPage(wizard, "Page 1")
+        page2 = TitledPage(wizard, "Page 2")
+        page3 = TitledPage(wizard, "Page 3")
+        page4 = TitledPage(wizard, "Page 4")
+
+        page1.sizer.Add(wxStaticText(page1, -1, """\
+This wizard is totally useless, but is meant to show how to
+chain simple wizard pages together in a non-dynamic manner.
+IOW, the order of the pages never changes, and so the
+wxWizardPageSimple class can be used for the pages."""))
+        wizard.FitToPage(page1)
+
+        # Use the convenience Chain function to connect the pages
+        wxWizardPageSimple_Chain(page1, page2)
+        wxWizardPageSimple_Chain(page2, page3)
+        wxWizardPageSimple_Chain(page3, page4)
+
+        if wizard.RunWizard(page1):
+            wxMessageBox("Wizard completed successfully", "That's all folks!")
+        else:
+            wxMessageBox("Wizard was cancelled", "That's all folks!")
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """<html><body>
+<h2><center>wxWizard</center></h2>
+
+wxWizard is the central class for implementing 'wizard-like'
+dialogs. These dialogs are mostly familiar to Windows users and are
+nothing else but a sequence of 'pages' each of them displayed inside a
+dialog which has the buttons to pass to the next (and previous) pages.
+<p>
+The wizards are typically used to decompose a complex dialog into
+several simple steps and are mainly useful to the novice users, hence
+it is important to keep them as simple as possible.
+
+</body></html>
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])])
+
diff --git a/wxPython/setup.py b/wxPython/setup.py
index 2c65f03fb8..f9ed42d4c7 100755
--- a/wxPython/setup.py
+++ b/wxPython/setup.py
@@ -473,6 +473,20 @@ if not GL_ONLY:
     wxpExtensions.append(ext)
 
 
+    # Extension for the wizard module
+    swig_sources = run_swig(['wizard.i'], 'src', GENDIR, PKGDIR,
+                            USE_SWIG, swig_force, swig_args, swig_deps)
+    ext = Extension('wizardc', swig_sources,
+                    include_dirs =  includes,
+                    define_macros = defines,
+                    library_dirs = libdirs,
+                    libraries = libs,
+                    extra_compile_args = cflags,
+                    extra_link_args = lflags,
+                    )
+    wxpExtensions.append(ext)
+
+
 #----------------------------------------------------------------------
 # Define the GLCanvas extension module
 #----------------------------------------------------------------------
diff --git a/wxPython/src/_wizardextras.py b/wxPython/src/_wizardextras.py
new file mode 100644
index 0000000000..4cd30aff7f
--- /dev/null
+++ b/wxPython/src/_wizardextras.py
@@ -0,0 +1,3 @@
+# Stuff these names into the wx namespace so wxPyConstructObject can find them
+import wx
+wx.wxWizardEventPtr         = wxWizardEventPtr
diff --git a/wxPython/src/helpers.h b/wxPython/src/helpers.h
index e0cb056cf7..3fefcfe62e 100644
--- a/wxPython/src/helpers.h
+++ b/wxPython/src/helpers.h
@@ -1740,4 +1740,50 @@ void wxPyCBH_delete(wxPyCallbackHelper* cbh);
 
 //---------------------------------------------------------------------------
 
+#define DEC_PYCALLBACK_WIZPG__pure(CBNAME)                                      \
+    wxWizardPage* CBNAME() const;
+
+#define IMP_PYCALLBACK_WIZPG__pure(CLASS, PCLASS, CBNAME)                       \
+    wxWizardPage* CLASS::CBNAME() const {                                       \
+        wxWizardPage* rv = NULL;                                                \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                SWIG_GetPtrObj(ro, (void **)&rv, "_wxWizardPage_p");            \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BITMAP__pure(CBNAME)                                     \
+    wxBitmap CBNAME() const;
+
+#define IMP_PYCALLBACK_BITMAP__pure(CLASS, PCLASS, CBNAME)                      \
+    wxBitmap CLASS::CBNAME() const {                                            \
+        wxBitmap rv;                                                            \
+        bool found;                                                             \
+        wxPyBeginBlockThreads();                                                \
+        if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
+            PyObject* ro;                                                       \
+            wxBitmap* ptr;                                                      \
+            ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));        \
+            if (ro) {                                                           \
+                if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxBitmap_p"))         \
+                    rv = *ptr;                                                  \
+                Py_DECREF(ro);                                                  \
+            }                                                                   \
+        }                                                                       \
+        wxPyEndBlockThreads();                                                  \
+        return rv;                                                              \
+    }
+
+//---------------------------------------------------------------------------
+
 #endif
diff --git a/wxPython/src/msw/wizard.cpp b/wxPython/src/msw/wizard.cpp
new file mode 100644
index 0000000000..3fd67fb3d6
--- /dev/null
+++ b/wxPython/src/msw/wizard.cpp
@@ -0,0 +1,2300 @@
+/*
+ * FILE : src/msw/wizard.cpp
+ * 
+ * This file was automatically generated by :
+ * Simplified Wrapper and Interface Generator (SWIG)
+ * Version 1.1 (Build 883)
+ * 
+ * Portions Copyright (c) 1995-1998
+ * The University of Utah and The Regents of the University of California.
+ * Permission is granted to distribute this file in any manner provided
+ * this notice remains intact.
+ * 
+ * Do not make changes to this file--changes will be lost!
+ *
+ */
+
+
+#define SWIGCODE
+/* Implementation : PYTHON */
+
+#define SWIGPYTHON
+#include <string.h>
+#include <stdlib.h>
+/* Definitions for Windows/Unix exporting */
+#if defined(__WIN32__)
+#   if defined(_MSC_VER)
+#	define SWIGEXPORT(a) __declspec(dllexport) a
+#   else
+#	if defined(__BORLANDC__)
+#	    define SWIGEXPORT(a) a _export
+#	else
+#	    define SWIGEXPORT(a) a
+#	endif
+#   endif
+#else
+#   define SWIGEXPORT(a) a
+#endif
+
+#include "Python.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void SWIG_MakePtr(char *, void *, char *);
+extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
+extern char *SWIG_GetPtr(char *, void **, char *);
+extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
+extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
+extern PyObject *SWIG_newvarlink(void);
+#ifdef __cplusplus
+}
+#endif
+#define SWIG_init    initwizardc
+
+#define SWIG_name    "wizardc"
+
+#include "wxPython.h"
+#include <wx/wizard.h>
+
+
+static PyObject* t_output_helper(PyObject* target, PyObject* o) {
+    PyObject*   o2;
+    PyObject*   o3;
+
+    if (!target) {
+        target = o;
+    } else if (target == Py_None) {
+        Py_DECREF(Py_None);
+        target = o;
+    } else {
+        if (!PyTuple_Check(target)) {
+            o2 = target;
+            target = PyTuple_New(1);
+            PyTuple_SetItem(target, 0, o2);
+        }
+        o3 = PyTuple_New(1);
+        PyTuple_SetItem(o3, 0, o);
+
+        o2 = target;
+        target = PySequence_Concat(o2, o3);
+        Py_DECREF(o2);
+        Py_DECREF(o3);
+    }
+    return target;
+}
+  // C++ Version of a Python aware class
+class wxPyWizardPage : public wxWizardPage {
+    DECLARE_ABSTRACT_CLASS(wxPyWizardPage);
+public:
+    wxPyWizardPage() : wxWizardPage() {}
+    wxPyWizardPage(wxWizard *parent,
+                   const wxBitmap& bitmap = wxNullBitmap,
+                   const wxChar* resource = NULL)
+        : wxWizardPage(parent, bitmap, resource) {}
+
+    DEC_PYCALLBACK_WIZPG__pure(GetPrev);
+    DEC_PYCALLBACK_WIZPG__pure(GetNext);
+    DEC_PYCALLBACK_BITMAP__pure(GetBitmap);
+
+    DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
+    DEC_PYCALLBACK_VOID_INT5(DoSetSize);
+    DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
+    DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
+
+    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
+    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
+    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
+
+    DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
+    DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
+
+    DEC_PYCALLBACK__(InitDialog);
+    DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
+    DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
+    DEC_PYCALLBACK_BOOL_(Validate);
+
+    DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
+    DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
+    DEC_PYCALLBACK_SIZE_const(GetMaxSize);
+
+    DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
+    DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
+
+    PYPRIVATE;
+};
+
+
+IMPLEMENT_ABSTRACT_CLASS(wxPyWizardPage, wxWizardPage);
+
+IMP_PYCALLBACK_WIZPG__pure(wxPyWizardPage, wxWizardPage, GetPrev);
+IMP_PYCALLBACK_WIZPG__pure(wxPyWizardPage, wxWizardPage, GetNext);
+IMP_PYCALLBACK_BITMAP__pure(wxPyWizardPage, wxWizardPage, GetBitmap);
+
+IMP_PYCALLBACK_VOID_INT4(wxPyWizardPage, wxWizardPage, DoMoveWindow);
+IMP_PYCALLBACK_VOID_INT5(wxPyWizardPage, wxWizardPage, DoSetSize);
+IMP_PYCALLBACK_VOID_INTINT(wxPyWizardPage, wxWizardPage, DoSetClientSize);
+IMP_PYCALLBACK_VOID_INTINT(wxPyWizardPage, wxWizardPage, DoSetVirtualSize);
+
+IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetSize);
+IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetClientSize);
+IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetPosition);
+
+IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, DoGetVirtualSize);
+IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, DoGetBestSize);
+
+IMP_PYCALLBACK__(wxPyWizardPage, wxWizardPage, InitDialog);
+IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, TransferDataFromWindow);
+IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, TransferDataToWindow);
+IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, Validate);
+
+IMP_PYCALLBACK_BOOL_const(wxPyWizardPage, wxWizardPage, AcceptsFocus);
+IMP_PYCALLBACK_BOOL_const(wxPyWizardPage, wxWizardPage, AcceptsFocusFromKeyboard);
+IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, GetMaxSize);
+
+IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWizardPage, wxWizardPage, AddChild);
+IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWizardPage, wxWizardPage, RemoveChild);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static void *SwigwxWizardEventTowxNotifyEvent(void *ptr) {
+    wxWizardEvent *src;
+    wxNotifyEvent *dest;
+    src = (wxWizardEvent *) ptr;
+    dest = (wxNotifyEvent *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardEventTowxCommandEvent(void *ptr) {
+    wxWizardEvent *src;
+    wxCommandEvent *dest;
+    src = (wxWizardEvent *) ptr;
+    dest = (wxCommandEvent *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardEventTowxEvent(void *ptr) {
+    wxWizardEvent *src;
+    wxEvent *dest;
+    src = (wxWizardEvent *) ptr;
+    dest = (wxEvent *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardEventTowxObject(void *ptr) {
+    wxWizardEvent *src;
+    wxObject *dest;
+    src = (wxWizardEvent *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxWizardEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3) (new wxWizardEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
+static PyObject *_wrap_new_wxWizardEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardEvent * _result;
+    wxEventType  _arg0 = (wxEventType ) wxEVT_NULL;
+    int  _arg1 = (int ) -1;
+    bool  _arg2 = (bool ) TRUE;
+    wxWizardPage * _arg3 = (wxWizardPage *) NULL;
+    int tempbool2 = (int) TRUE;
+    PyObject * _argo3 = 0;
+    char *_kwnames[] = { "type","id","direction","page", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|iiiO:new_wxWizardEvent",_kwnames,&_arg0,&_arg1,&tempbool2,&_argo3)) 
+        return NULL;
+    _arg2 = (bool ) tempbool2;
+    if (_argo3) {
+        if (_argo3 == Py_None) { _arg3 = NULL; }
+        else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxWizardEvent. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizardEvent *)new_wxWizardEvent(_arg0,_arg1,_arg2,_arg3);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizardEvent_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxWizardEvent_GetDirection(_swigobj)  (_swigobj->GetDirection())
+static PyObject *_wrap_wxWizardEvent_GetDirection(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxWizardEvent * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizardEvent_GetDirection",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardEvent_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardEvent_GetDirection. Expected _wxWizardEvent_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxWizardEvent_GetDirection(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxWizardEvent_GetPage(_swigobj)  (_swigobj->GetPage())
+static PyObject *_wrap_wxWizardEvent_GetPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPage * _result;
+    wxWizardEvent * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizardEvent_GetPage",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardEvent_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardEvent_GetPage. Expected _wxWizardEvent_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizardPage *)wxWizardEvent_GetPage(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizardPage_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+static void *SwigwxWizardPageTowxPanel(void *ptr) {
+    wxWizardPage *src;
+    wxPanel *dest;
+    src = (wxWizardPage *) ptr;
+    dest = (wxPanel *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardPageTowxWindow(void *ptr) {
+    wxWizardPage *src;
+    wxWindow *dest;
+    src = (wxWizardPage *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardPageTowxEvtHandler(void *ptr) {
+    wxWizardPage *src;
+    wxEvtHandler *dest;
+    src = (wxWizardPage *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardPageTowxObject(void *ptr) {
+    wxWizardPage *src;
+    wxObject *dest;
+    src = (wxWizardPage *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define wxWizardPage_Create(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Create(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxWizardPage_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxWizardPage * _arg0;
+    wxWizard * _arg1;
+    wxBitmap * _arg2 = (wxBitmap *) &wxNullBitmap;
+    char * _arg3 = (char *) NULL;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    PyObject * _argo2 = 0;
+    char *_kwnames[] = { "self","parent","bitmap","resource", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|Os:wxWizardPage_Create",_kwnames,&_argo0,&_argo1,&_argo2,&_arg3)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPage_Create. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizardPage_Create. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo2) {
+        if (_argo2 == Py_None) { _arg2 = NULL; }
+        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxBitmap_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxWizardPage_Create. Expected _wxBitmap_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxWizardPage_Create(_arg0,_arg1,*_arg2,_arg3);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxWizardPage_Init(_swigobj)  (_swigobj->Init())
+static PyObject *_wrap_wxWizardPage_Init(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizardPage_Init",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPage_Init. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizardPage_Init(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxWizardPage_GetPrev(_swigobj)  (_swigobj->GetPrev())
+static PyObject *_wrap_wxWizardPage_GetPrev(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPage * _result;
+    wxWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizardPage_GetPrev",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPage_GetPrev. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizardPage *)wxWizardPage_GetPrev(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizardPage_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxWizardPage_GetNext(_swigobj)  (_swigobj->GetNext())
+static PyObject *_wrap_wxWizardPage_GetNext(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPage * _result;
+    wxWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizardPage_GetNext",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPage_GetNext. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizardPage *)wxWizardPage_GetNext(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizardPage_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxWizardPage_GetBitmap(_swigobj)  (_swigobj->GetBitmap())
+static PyObject *_wrap_wxWizardPage_GetBitmap(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxBitmap * _result;
+    wxWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizardPage_GetBitmap",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPage_GetBitmap. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxBitmap (wxWizardPage_GetBitmap(_arg0));
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+static void *SwigwxPyWizardPageTowxWizardPage(void *ptr) {
+    wxPyWizardPage *src;
+    wxWizardPage *dest;
+    src = (wxPyWizardPage *) ptr;
+    dest = (wxWizardPage *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxPyWizardPageTowxPanel(void *ptr) {
+    wxPyWizardPage *src;
+    wxPanel *dest;
+    src = (wxPyWizardPage *) ptr;
+    dest = (wxPanel *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxPyWizardPageTowxWindow(void *ptr) {
+    wxPyWizardPage *src;
+    wxWindow *dest;
+    src = (wxPyWizardPage *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxPyWizardPageTowxEvtHandler(void *ptr) {
+    wxPyWizardPage *src;
+    wxEvtHandler *dest;
+    src = (wxPyWizardPage *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxPyWizardPageTowxObject(void *ptr) {
+    wxPyWizardPage *src;
+    wxObject *dest;
+    src = (wxPyWizardPage *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxPyWizardPage(_swigarg0,_swigarg1,_swigarg2) (new wxPyWizardPage(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_new_wxPyWizardPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _result;
+    wxWizard * _arg0;
+    wxBitmap * _arg1 = (wxBitmap *) &wxNullBitmap;
+    char * _arg2 = (char *) NULL;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "parent","bitmap","resource", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|Os:new_wxPyWizardPage",_kwnames,&_argo0,&_argo1,&_arg2)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxPyWizardPage. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxBitmap_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxPyWizardPage. Expected _wxBitmap_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxPyWizardPage *)new_wxPyWizardPage(_arg0,*_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyWizardPage_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define new_wxPrePyWizardPage() (new wxPyWizardPage())
+static PyObject *_wrap_new_wxPrePyWizardPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _result;
+    char *_kwnames[] = {  NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPrePyWizardPage",_kwnames)) 
+        return NULL;
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxPyWizardPage *)new_wxPrePyWizardPage();
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyWizardPage_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxPyWizardPage_Create(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Create(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxPyWizardPage_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxPyWizardPage * _arg0;
+    wxWizard * _arg1;
+    wxBitmap * _arg2 = (wxBitmap *) &wxNullBitmap;
+    char * _arg3 = (char *) NULL;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    PyObject * _argo2 = 0;
+    char *_kwnames[] = { "self","parent","bitmap","resource", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|Os:wxPyWizardPage_Create",_kwnames,&_argo0,&_argo1,&_argo2,&_arg3)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_Create. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyWizardPage_Create. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo2) {
+        if (_argo2 == Py_None) { _arg2 = NULL; }
+        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxBitmap_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxPyWizardPage_Create. Expected _wxBitmap_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyWizardPage_Create(_arg0,_arg1,*_arg2,_arg3);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxPyWizardPage__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyWizardPage__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    PyObject * _arg1;
+    PyObject * _arg2;
+    PyObject * _argo0 = 0;
+    PyObject * _obj1 = 0;
+    PyObject * _obj2 = 0;
+    char *_kwnames[] = { "self","self","_class", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyWizardPage__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage__setCallbackInfo. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+  _arg1 = _obj1;
+}
+{
+  _arg2 = _obj2;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage__setCallbackInfo(_arg0,_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoMoveWindow(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->base_DoMoveWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
+static PyObject *_wrap_wxPyWizardPage_base_DoMoveWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    int  _arg1;
+    int  _arg2;
+    int  _arg3;
+    int  _arg4;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self","x","y","width","height", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii:wxPyWizardPage_base_DoMoveWindow",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoMoveWindow. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_DoMoveWindow(_arg0,_arg1,_arg2,_arg3,_arg4);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoSetSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->base_DoSetSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_wxPyWizardPage_base_DoSetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    int  _arg1;
+    int  _arg2;
+    int  _arg3;
+    int  _arg4;
+    int  _arg5 = (int ) wxSIZE_AUTO;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self","x","y","width","height","sizeFlags", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|i:wxPyWizardPage_base_DoSetSize",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoSetSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_DoSetSize(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoSetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DoSetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyWizardPage_base_DoSetClientSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    int  _arg1;
+    int  _arg2;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self","width","height", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxPyWizardPage_base_DoSetClientSize",_kwnames,&_argo0,&_arg1,&_arg2)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoSetClientSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_DoSetClientSize(_arg0,_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoSetVirtualSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DoSetVirtualSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyWizardPage_base_DoSetVirtualSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    int  _arg1;
+    int  _arg2;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self","x","y", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxPyWizardPage_base_DoSetVirtualSize",_kwnames,&_argo0,&_arg1,&_arg2)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoSetVirtualSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_DoSetVirtualSize(_arg0,_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoGetSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DoGetSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyWizardPage_base_DoGetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_DoGetSize",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoGetSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_DoGetSize(_arg0,_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg1));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg2));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoGetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DoGetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyWizardPage_base_DoGetClientSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_DoGetClientSize",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoGetClientSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_DoGetClientSize(_arg0,_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg1));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg2));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoGetPosition(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DoGetPosition(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyWizardPage_base_DoGetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_DoGetPosition",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoGetPosition. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_DoGetPosition(_arg0,_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg1));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg2));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoGetVirtualSize(_swigobj)  (_swigobj->base_DoGetVirtualSize())
+static PyObject *_wrap_wxPyWizardPage_base_DoGetVirtualSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxSize * _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_DoGetVirtualSize",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoGetVirtualSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxSize (wxPyWizardPage_base_DoGetVirtualSize(_arg0));
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_DoGetBestSize(_swigobj)  (_swigobj->base_DoGetBestSize())
+static PyObject *_wrap_wxPyWizardPage_base_DoGetBestSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxSize * _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_DoGetBestSize",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_DoGetBestSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxSize (wxPyWizardPage_base_DoGetBestSize(_arg0));
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_InitDialog(_swigobj)  (_swigobj->base_InitDialog())
+static PyObject *_wrap_wxPyWizardPage_base_InitDialog(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_InitDialog",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_InitDialog. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_InitDialog(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_TransferDataToWindow(_swigobj)  (_swigobj->base_TransferDataToWindow())
+static PyObject *_wrap_wxPyWizardPage_base_TransferDataToWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_TransferDataToWindow",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_TransferDataToWindow. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyWizardPage_base_TransferDataToWindow(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_TransferDataFromWindow(_swigobj)  (_swigobj->base_TransferDataFromWindow())
+static PyObject *_wrap_wxPyWizardPage_base_TransferDataFromWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_TransferDataFromWindow",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_TransferDataFromWindow. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyWizardPage_base_TransferDataFromWindow(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_Validate(_swigobj)  (_swigobj->base_Validate())
+static PyObject *_wrap_wxPyWizardPage_base_Validate(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_Validate",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_Validate. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyWizardPage_base_Validate(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_AcceptsFocus(_swigobj)  (_swigobj->base_AcceptsFocus())
+static PyObject *_wrap_wxPyWizardPage_base_AcceptsFocus(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_AcceptsFocus",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_AcceptsFocus. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyWizardPage_base_AcceptsFocus(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_AcceptsFocusFromKeyboard(_swigobj)  (_swigobj->base_AcceptsFocusFromKeyboard())
+static PyObject *_wrap_wxPyWizardPage_base_AcceptsFocusFromKeyboard(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_AcceptsFocusFromKeyboard",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_AcceptsFocusFromKeyboard. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxPyWizardPage_base_AcceptsFocusFromKeyboard(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_GetMaxSize(_swigobj)  (_swigobj->base_GetMaxSize())
+static PyObject *_wrap_wxPyWizardPage_base_GetMaxSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxSize * _result;
+    wxPyWizardPage * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyWizardPage_base_GetMaxSize",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_GetMaxSize. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxSize (wxPyWizardPage_base_GetMaxSize(_arg0));
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_AddChild(_swigobj,_swigarg0)  (_swigobj->base_AddChild(_swigarg0))
+static PyObject *_wrap_wxPyWizardPage_base_AddChild(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    wxWindow * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","child", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyWizardPage_base_AddChild",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_AddChild. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyWizardPage_base_AddChild. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_AddChild(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxPyWizardPage_base_RemoveChild(_swigobj,_swigarg0)  (_swigobj->base_RemoveChild(_swigarg0))
+static PyObject *_wrap_wxPyWizardPage_base_RemoveChild(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyWizardPage * _arg0;
+    wxWindow * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","child", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyWizardPage_base_RemoveChild",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyWizardPage_base_RemoveChild. Expected _wxPyWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyWizardPage_base_RemoveChild. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxPyWizardPage_base_RemoveChild(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+static void *SwigwxWizardPageSimpleTowxWizardPage(void *ptr) {
+    wxWizardPageSimple *src;
+    wxWizardPage *dest;
+    src = (wxWizardPageSimple *) ptr;
+    dest = (wxWizardPage *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardPageSimpleTowxPanel(void *ptr) {
+    wxWizardPageSimple *src;
+    wxPanel *dest;
+    src = (wxWizardPageSimple *) ptr;
+    dest = (wxPanel *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardPageSimpleTowxWindow(void *ptr) {
+    wxWizardPageSimple *src;
+    wxWindow *dest;
+    src = (wxWizardPageSimple *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardPageSimpleTowxEvtHandler(void *ptr) {
+    wxWizardPageSimple *src;
+    wxEvtHandler *dest;
+    src = (wxWizardPageSimple *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardPageSimpleTowxObject(void *ptr) {
+    wxWizardPageSimple *src;
+    wxObject *dest;
+    src = (wxWizardPageSimple *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxWizardPageSimple(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxWizardPageSimple(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_new_wxWizardPageSimple(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPageSimple * _result;
+    wxWizard * _arg0;
+    wxWizardPage * _arg1 = (wxWizardPage *) NULL;
+    wxWizardPage * _arg2 = (wxWizardPage *) NULL;
+    wxBitmap * _arg3 = (wxBitmap *) &wxNullBitmap;
+    wxChar * _arg4 = (wxChar *) NULL;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    PyObject * _argo2 = 0;
+    PyObject * _argo3 = 0;
+    char *_kwnames[] = { "parent","prev","next","bitmap","resource", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|OOOs:new_wxWizardPageSimple",_kwnames,&_argo0,&_argo1,&_argo2,&_argo3,&_arg4)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxWizardPageSimple. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxWizardPageSimple. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo2) {
+        if (_argo2 == Py_None) { _arg2 = NULL; }
+        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxWizardPageSimple. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo3) {
+        if (_argo3 == Py_None) { _arg3 = NULL; }
+        else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxBitmap_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxWizardPageSimple. Expected _wxBitmap_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizardPageSimple *)new_wxWizardPageSimple(_arg0,_arg1,_arg2,*_arg3,_arg4);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizardPageSimple_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define new_wxPreWizardPageSimple() (new wxWizardPageSimple())
+static PyObject *_wrap_new_wxPreWizardPageSimple(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPageSimple * _result;
+    char *_kwnames[] = {  NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPreWizardPageSimple",_kwnames)) 
+        return NULL;
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizardPageSimple *)new_wxPreWizardPageSimple();
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizardPageSimple_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxWizardPageSimple_Create(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->Create(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_wxWizardPageSimple_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxWizardPageSimple * _arg0;
+    wxWizard * _arg1 = (wxWizard *) NULL;
+    wxWizardPage * _arg2 = (wxWizardPage *) NULL;
+    wxWizardPage * _arg3 = (wxWizardPage *) NULL;
+    wxBitmap * _arg4 = (wxBitmap *) &wxNullBitmap;
+    wxChar * _arg5 = (wxChar *) NULL;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    PyObject * _argo2 = 0;
+    PyObject * _argo3 = 0;
+    PyObject * _argo4 = 0;
+    char *_kwnames[] = { "self","parent","prev","next","bitmap","resource", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|OOOOs:wxWizardPageSimple_Create",_kwnames,&_argo0,&_argo1,&_argo2,&_argo3,&_argo4,&_arg5)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPageSimple_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPageSimple_Create. Expected _wxWizardPageSimple_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizardPageSimple_Create. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo2) {
+        if (_argo2 == Py_None) { _arg2 = NULL; }
+        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxWizardPageSimple_Create. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo3) {
+        if (_argo3 == Py_None) { _arg3 = NULL; }
+        else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxWizardPageSimple_Create. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+    if (_argo4) {
+        if (_argo4 == Py_None) { _arg4 = NULL; }
+        else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxBitmap_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxWizardPageSimple_Create. Expected _wxBitmap_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxWizardPageSimple_Create(_arg0,_arg1,_arg2,_arg3,*_arg4,_arg5);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxWizardPageSimple_Init(_swigobj)  (_swigobj->Init())
+static PyObject *_wrap_wxWizardPageSimple_Init(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPageSimple * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizardPageSimple_Init",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPageSimple_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPageSimple_Init. Expected _wxWizardPageSimple_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizardPageSimple_Init(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxWizardPageSimple_SetPrev(_swigobj,_swigarg0)  (_swigobj->SetPrev(_swigarg0))
+static PyObject *_wrap_wxWizardPageSimple_SetPrev(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPageSimple * _arg0;
+    wxWizardPage * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","prev", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWizardPageSimple_SetPrev",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPageSimple_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPageSimple_SetPrev. Expected _wxWizardPageSimple_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizardPageSimple_SetPrev. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizardPageSimple_SetPrev(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxWizardPageSimple_SetNext(_swigobj,_swigarg0)  (_swigobj->SetNext(_swigarg0))
+static PyObject *_wrap_wxWizardPageSimple_SetNext(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPageSimple * _arg0;
+    wxWizardPage * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","next", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWizardPageSimple_SetNext",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPageSimple_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPageSimple_SetNext. Expected _wxWizardPageSimple_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizardPageSimple_SetNext. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizardPageSimple_SetNext(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+static PyObject *_wrap_wxWizardPageSimple_Chain(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPageSimple * _arg0;
+    wxWizardPageSimple * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "first","second", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWizardPageSimple_Chain",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizardPageSimple_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizardPageSimple_Chain. Expected _wxWizardPageSimple_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizardPageSimple_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizardPageSimple_Chain. Expected _wxWizardPageSimple_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizardPageSimple::Chain(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+static void *SwigwxWizardTowxDialog(void *ptr) {
+    wxWizard *src;
+    wxDialog *dest;
+    src = (wxWizard *) ptr;
+    dest = (wxDialog *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardTowxTopLevelWindow(void *ptr) {
+    wxWizard *src;
+    wxTopLevelWindow *dest;
+    src = (wxWizard *) ptr;
+    dest = (wxTopLevelWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardTowxWindow(void *ptr) {
+    wxWizard *src;
+    wxWindow *dest;
+    src = (wxWizard *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardTowxEvtHandler(void *ptr) {
+    wxWizard *src;
+    wxEvtHandler *dest;
+    src = (wxWizard *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxWizardTowxObject(void *ptr) {
+    wxWizard *src;
+    wxObject *dest;
+    src = (wxWizard *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxWizard(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxWizard(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_new_wxWizard(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizard * _result;
+    wxWindow * _arg0;
+    int  _arg1 = (int ) -1;
+    wxString * _arg2 = (wxString *) &wxEmptyString;
+    wxBitmap * _arg3 = (wxBitmap *) &wxNullBitmap;
+    wxPoint * _arg4 = (wxPoint *) &wxDefaultPosition;
+    PyObject * _argo0 = 0;
+    PyObject * _obj2 = 0;
+    PyObject * _argo3 = 0;
+    wxPoint  temp;
+    PyObject * _obj4 = 0;
+    char *_kwnames[] = { "parent","id","title","bitmap","pos", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOO:new_wxWizard",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_obj4)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxWizard. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+    if (_obj2)
+{
+    _arg2 = wxString_in_helper(_obj2);
+    if (_arg2 == NULL)
+        return NULL;
+}
+    if (_argo3) {
+        if (_argo3 == Py_None) { _arg3 = NULL; }
+        else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxBitmap_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxWizard. Expected _wxBitmap_p.");
+        return NULL;
+        }
+    }
+    if (_obj4)
+{
+    _arg4 = &temp;
+    if (! wxPoint_helper(_obj4, &_arg4))
+        return NULL;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizard *)new_wxWizard(_arg0,_arg1,*_arg2,*_arg3,*_arg4);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizard_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+{
+    if (_obj2)
+        delete _arg2;
+}
+    return _resultobj;
+}
+
+#define new_wxPreWizard() (new wxWizard())
+static PyObject *_wrap_new_wxPreWizard(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizard * _result;
+    char *_kwnames[] = {  NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPreWizard",_kwnames)) 
+        return NULL;
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizard *)new_wxPreWizard();
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizard_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxWizard_Create(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->Create(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_wxWizard_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxWizard * _arg0;
+    wxWindow * _arg1;
+    int  _arg2 = (int ) -1;
+    wxString * _arg3 = (wxString *) &wxEmptyString;
+    wxBitmap * _arg4 = (wxBitmap *) &wxNullBitmap;
+    wxPoint * _arg5 = (wxPoint *) &wxDefaultPosition;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    PyObject * _obj3 = 0;
+    PyObject * _argo4 = 0;
+    wxPoint  temp;
+    PyObject * _obj5 = 0;
+    char *_kwnames[] = { "self","parent","id","title","bitmap","pos", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|iOOO:wxWizard_Create",_kwnames,&_argo0,&_argo1,&_arg2,&_obj3,&_argo4,&_obj5)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_Create. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizard_Create. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+    if (_obj3)
+{
+    _arg3 = wxString_in_helper(_obj3);
+    if (_arg3 == NULL)
+        return NULL;
+}
+    if (_argo4) {
+        if (_argo4 == Py_None) { _arg4 = NULL; }
+        else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxBitmap_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxWizard_Create. Expected _wxBitmap_p.");
+        return NULL;
+        }
+    }
+    if (_obj5)
+{
+    _arg5 = &temp;
+    if (! wxPoint_helper(_obj5, &_arg5))
+        return NULL;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxWizard_Create(_arg0,_arg1,_arg2,*_arg3,*_arg4,*_arg5);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+{
+    if (_obj3)
+        delete _arg3;
+}
+    return _resultobj;
+}
+
+#define wxWizard_Init(_swigobj)  (_swigobj->Init())
+static PyObject *_wrap_wxWizard_Init(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizard * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizard_Init",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_Init. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizard_Init(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxWizard_RunWizard(_swigobj,_swigarg0)  (_swigobj->RunWizard(_swigarg0))
+static PyObject *_wrap_wxWizard_RunWizard(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxWizard * _arg0;
+    wxWizardPage * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","firstPage", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWizard_RunWizard",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_RunWizard. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizard_RunWizard. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxWizard_RunWizard(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxWizard_GetCurrentPage(_swigobj)  (_swigobj->GetCurrentPage())
+static PyObject *_wrap_wxWizard_GetCurrentPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizardPage * _result;
+    wxWizard * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizard_GetCurrentPage",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_GetCurrentPage. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (wxWizardPage *)wxWizard_GetCurrentPage(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxWizardPage_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxWizard_SetPageSize(_swigobj,_swigarg0)  (_swigobj->SetPageSize(_swigarg0))
+static PyObject *_wrap_wxWizard_SetPageSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizard * _arg0;
+    wxSize * _arg1;
+    PyObject * _argo0 = 0;
+    wxSize  temp;
+    PyObject * _obj1 = 0;
+    char *_kwnames[] = { "self","size", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWizard_SetPageSize",_kwnames,&_argo0,&_obj1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_SetPageSize. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+{
+    _arg1 = &temp;
+    if (! wxSize_helper(_obj1, &_arg1))
+        return NULL;
+}
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizard_SetPageSize(_arg0,*_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxWizard_GetPageSize(_swigobj)  (_swigobj->GetPageSize())
+static PyObject *_wrap_wxWizard_GetPageSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxSize * _result;
+    wxWizard * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizard_GetPageSize",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_GetPageSize. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = new wxSize (wxWizard_GetPageSize(_arg0));
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxWizard_FitToPage(_swigobj,_swigarg0)  (_swigobj->FitToPage(_swigarg0))
+static PyObject *_wrap_wxWizard_FitToPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWizard * _arg0;
+    wxWizardPage * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","firstPage", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWizard_FitToPage",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_FitToPage. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizard_FitToPage. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    wxWizard_FitToPage(_arg0,_arg1);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxWizard_IsRunning(_swigobj)  (_swigobj->IsRunning())
+static PyObject *_wrap_wxWizard_IsRunning(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxWizard * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWizard_IsRunning",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_IsRunning. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxWizard_IsRunning(_arg0);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+#define wxWizard_ShowPage(_swigobj,_swigarg0,_swigarg1)  (_swigobj->ShowPage(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxWizard_ShowPage(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    bool  _result;
+    wxWizard * _arg0;
+    wxWizardPage * _arg1;
+    bool  _arg2 = (bool ) TRUE;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    int tempbool2 = (int) TRUE;
+    char *_kwnames[] = { "self","page","goingForward", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxWizard_ShowPage",_kwnames,&_argo0,&_argo1,&tempbool2)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWizard_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWizard_ShowPage. Expected _wxWizard_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWizardPage_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWizard_ShowPage. Expected _wxWizardPage_p.");
+        return NULL;
+        }
+    }
+    _arg2 = (bool ) tempbool2;
+{
+    PyThreadState* __tstate = wxPyBeginAllowThreads();
+    _result = (bool )wxWizard_ShowPage(_arg0,_arg1,_arg2);
+
+    wxPyEndAllowThreads(__tstate);
+    if (PyErr_Occurred()) return NULL;
+}    _resultobj = Py_BuildValue("i",_result);
+    return _resultobj;
+}
+
+static PyMethodDef wizardcMethods[] = {
+	 { "wxWizard_ShowPage", (PyCFunction) _wrap_wxWizard_ShowPage, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_IsRunning", (PyCFunction) _wrap_wxWizard_IsRunning, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_FitToPage", (PyCFunction) _wrap_wxWizard_FitToPage, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_GetPageSize", (PyCFunction) _wrap_wxWizard_GetPageSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_SetPageSize", (PyCFunction) _wrap_wxWizard_SetPageSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_GetCurrentPage", (PyCFunction) _wrap_wxWizard_GetCurrentPage, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_RunWizard", (PyCFunction) _wrap_wxWizard_RunWizard, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_Init", (PyCFunction) _wrap_wxWizard_Init, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizard_Create", (PyCFunction) _wrap_wxWizard_Create, METH_VARARGS | METH_KEYWORDS },
+	 { "new_wxPreWizard", (PyCFunction) _wrap_new_wxPreWizard, METH_VARARGS | METH_KEYWORDS },
+	 { "new_wxWizard", (PyCFunction) _wrap_new_wxWizard, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPageSimple_Chain", (PyCFunction) _wrap_wxWizardPageSimple_Chain, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPageSimple_SetNext", (PyCFunction) _wrap_wxWizardPageSimple_SetNext, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPageSimple_SetPrev", (PyCFunction) _wrap_wxWizardPageSimple_SetPrev, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPageSimple_Init", (PyCFunction) _wrap_wxWizardPageSimple_Init, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPageSimple_Create", (PyCFunction) _wrap_wxWizardPageSimple_Create, METH_VARARGS | METH_KEYWORDS },
+	 { "new_wxPreWizardPageSimple", (PyCFunction) _wrap_new_wxPreWizardPageSimple, METH_VARARGS | METH_KEYWORDS },
+	 { "new_wxWizardPageSimple", (PyCFunction) _wrap_new_wxWizardPageSimple, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_RemoveChild", (PyCFunction) _wrap_wxPyWizardPage_base_RemoveChild, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_AddChild", (PyCFunction) _wrap_wxPyWizardPage_base_AddChild, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_GetMaxSize", (PyCFunction) _wrap_wxPyWizardPage_base_GetMaxSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_wxPyWizardPage_base_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_AcceptsFocus", (PyCFunction) _wrap_wxPyWizardPage_base_AcceptsFocus, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_Validate", (PyCFunction) _wrap_wxPyWizardPage_base_Validate, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_TransferDataFromWindow", (PyCFunction) _wrap_wxPyWizardPage_base_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_TransferDataToWindow", (PyCFunction) _wrap_wxPyWizardPage_base_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_InitDialog", (PyCFunction) _wrap_wxPyWizardPage_base_InitDialog, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoGetBestSize", (PyCFunction) _wrap_wxPyWizardPage_base_DoGetBestSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoGetVirtualSize", (PyCFunction) _wrap_wxPyWizardPage_base_DoGetVirtualSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoGetPosition", (PyCFunction) _wrap_wxPyWizardPage_base_DoGetPosition, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoGetClientSize", (PyCFunction) _wrap_wxPyWizardPage_base_DoGetClientSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoGetSize", (PyCFunction) _wrap_wxPyWizardPage_base_DoGetSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoSetVirtualSize", (PyCFunction) _wrap_wxPyWizardPage_base_DoSetVirtualSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoSetClientSize", (PyCFunction) _wrap_wxPyWizardPage_base_DoSetClientSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoSetSize", (PyCFunction) _wrap_wxPyWizardPage_base_DoSetSize, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_base_DoMoveWindow", (PyCFunction) _wrap_wxPyWizardPage_base_DoMoveWindow, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage__setCallbackInfo", (PyCFunction) _wrap_wxPyWizardPage__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
+	 { "wxPyWizardPage_Create", (PyCFunction) _wrap_wxPyWizardPage_Create, METH_VARARGS | METH_KEYWORDS },
+	 { "new_wxPrePyWizardPage", (PyCFunction) _wrap_new_wxPrePyWizardPage, METH_VARARGS | METH_KEYWORDS },
+	 { "new_wxPyWizardPage", (PyCFunction) _wrap_new_wxPyWizardPage, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPage_GetBitmap", (PyCFunction) _wrap_wxWizardPage_GetBitmap, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPage_GetNext", (PyCFunction) _wrap_wxWizardPage_GetNext, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPage_GetPrev", (PyCFunction) _wrap_wxWizardPage_GetPrev, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPage_Init", (PyCFunction) _wrap_wxWizardPage_Init, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardPage_Create", (PyCFunction) _wrap_wxWizardPage_Create, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardEvent_GetPage", (PyCFunction) _wrap_wxWizardEvent_GetPage, METH_VARARGS | METH_KEYWORDS },
+	 { "wxWizardEvent_GetDirection", (PyCFunction) _wrap_wxWizardEvent_GetDirection, METH_VARARGS | METH_KEYWORDS },
+	 { "new_wxWizardEvent", (PyCFunction) _wrap_new_wxWizardEvent, METH_VARARGS | METH_KEYWORDS },
+	 { NULL, NULL }
+};
+#ifdef __cplusplus
+}
+#endif
+/*
+ * This table is used by the pointer type-checker
+ */
+static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
+    { "_wxEvent","_wxWizardEvent",SwigwxWizardEventTowxEvent},
+    { "_signed_long","_long",0},
+    { "_wxPrintQuality","_wxCoord",0},
+    { "_wxPrintQuality","_int",0},
+    { "_wxPrintQuality","_signed_int",0},
+    { "_wxPrintQuality","_unsigned_int",0},
+    { "_wxPrintQuality","_wxWindowID",0},
+    { "_wxPrintQuality","_uint",0},
+    { "_wxPrintQuality","_EBool",0},
+    { "_wxPrintQuality","_size_t",0},
+    { "_wxPrintQuality","_time_t",0},
+    { "_wxNotifyEvent","_wxWizardEvent",SwigwxWizardEventTowxNotifyEvent},
+    { "_wxWizardPage","_wxWizardPageSimple",SwigwxWizardPageSimpleTowxWizardPage},
+    { "_wxWizardPage","_wxPyWizardPage",SwigwxPyWizardPageTowxWizardPage},
+    { "_byte","_unsigned_char",0},
+    { "_long","_unsigned_long",0},
+    { "_long","_signed_long",0},
+    { "_size_t","_wxCoord",0},
+    { "_size_t","_wxPrintQuality",0},
+    { "_size_t","_time_t",0},
+    { "_size_t","_unsigned_int",0},
+    { "_size_t","_int",0},
+    { "_size_t","_wxWindowID",0},
+    { "_size_t","_uint",0},
+    { "_wxPanel","_wxWizardPageSimple",SwigwxWizardPageSimpleTowxPanel},
+    { "_wxPanel","_wxPyWizardPage",SwigwxPyWizardPageTowxPanel},
+    { "_wxPanel","_wxWizardPage",SwigwxWizardPageTowxPanel},
+    { "_wxTopLevelWindow","_wxWizard",SwigwxWizardTowxTopLevelWindow},
+    { "_uint","_wxCoord",0},
+    { "_uint","_wxPrintQuality",0},
+    { "_uint","_time_t",0},
+    { "_uint","_size_t",0},
+    { "_uint","_unsigned_int",0},
+    { "_uint","_int",0},
+    { "_uint","_wxWindowID",0},
+    { "_wxChar","_char",0},
+    { "_wxCommandEvent","_wxWizardEvent",SwigwxWizardEventTowxCommandEvent},
+    { "_char","_wxChar",0},
+    { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
+    { "_EBool","_wxCoord",0},
+    { "_EBool","_wxPrintQuality",0},
+    { "_EBool","_signed_int",0},
+    { "_EBool","_int",0},
+    { "_EBool","_wxWindowID",0},
+    { "_unsigned_long","_long",0},
+    { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
+    { "_signed_int","_wxCoord",0},
+    { "_signed_int","_wxPrintQuality",0},
+    { "_signed_int","_EBool",0},
+    { "_signed_int","_wxWindowID",0},
+    { "_signed_int","_int",0},
+    { "_WXTYPE","_short",0},
+    { "_WXTYPE","_signed_short",0},
+    { "_WXTYPE","_unsigned_short",0},
+    { "_unsigned_short","_WXTYPE",0},
+    { "_unsigned_short","_short",0},
+    { "_wxObject","_wxWizard",SwigwxWizardTowxObject},
+    { "_wxObject","_wxWizardPageSimple",SwigwxWizardPageSimpleTowxObject},
+    { "_wxObject","_wxPyWizardPage",SwigwxPyWizardPageTowxObject},
+    { "_wxObject","_wxWizardPage",SwigwxWizardPageTowxObject},
+    { "_wxObject","_wxWizardEvent",SwigwxWizardEventTowxObject},
+    { "_signed_short","_WXTYPE",0},
+    { "_signed_short","_short",0},
+    { "_unsigned_char","_byte",0},
+    { "_unsigned_int","_wxCoord",0},
+    { "_unsigned_int","_wxPrintQuality",0},
+    { "_unsigned_int","_time_t",0},
+    { "_unsigned_int","_size_t",0},
+    { "_unsigned_int","_uint",0},
+    { "_unsigned_int","_wxWindowID",0},
+    { "_unsigned_int","_int",0},
+    { "_wxDialog","_wxWizard",SwigwxWizardTowxDialog},
+    { "_short","_WXTYPE",0},
+    { "_short","_unsigned_short",0},
+    { "_short","_signed_short",0},
+    { "_wxWindowID","_wxCoord",0},
+    { "_wxWindowID","_wxPrintQuality",0},
+    { "_wxWindowID","_time_t",0},
+    { "_wxWindowID","_size_t",0},
+    { "_wxWindowID","_EBool",0},
+    { "_wxWindowID","_uint",0},
+    { "_wxWindowID","_int",0},
+    { "_wxWindowID","_signed_int",0},
+    { "_wxWindowID","_unsigned_int",0},
+    { "_int","_wxCoord",0},
+    { "_int","_wxPrintQuality",0},
+    { "_int","_time_t",0},
+    { "_int","_size_t",0},
+    { "_int","_EBool",0},
+    { "_int","_uint",0},
+    { "_int","_wxWindowID",0},
+    { "_int","_unsigned_int",0},
+    { "_int","_signed_int",0},
+    { "_time_t","_wxCoord",0},
+    { "_time_t","_wxPrintQuality",0},
+    { "_time_t","_unsigned_int",0},
+    { "_time_t","_int",0},
+    { "_time_t","_wxWindowID",0},
+    { "_time_t","_uint",0},
+    { "_time_t","_size_t",0},
+    { "_wxCoord","_int",0},
+    { "_wxCoord","_signed_int",0},
+    { "_wxCoord","_unsigned_int",0},
+    { "_wxCoord","_wxWindowID",0},
+    { "_wxCoord","_uint",0},
+    { "_wxCoord","_EBool",0},
+    { "_wxCoord","_size_t",0},
+    { "_wxCoord","_time_t",0},
+    { "_wxCoord","_wxPrintQuality",0},
+    { "_wxEvtHandler","_wxWizard",SwigwxWizardTowxEvtHandler},
+    { "_wxEvtHandler","_wxWizardPageSimple",SwigwxWizardPageSimpleTowxEvtHandler},
+    { "_wxEvtHandler","_wxPyWizardPage",SwigwxPyWizardPageTowxEvtHandler},
+    { "_wxEvtHandler","_wxWizardPage",SwigwxWizardPageTowxEvtHandler},
+    { "_wxWindow","_wxWizard",SwigwxWizardTowxWindow},
+    { "_wxWindow","_wxWizardPageSimple",SwigwxWizardPageSimpleTowxWindow},
+    { "_wxWindow","_wxPyWizardPage",SwigwxPyWizardPageTowxWindow},
+    { "_wxWindow","_wxWizardPage",SwigwxWizardPageTowxWindow},
+{0,0,0}};
+
+static PyObject *SWIG_globals;
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT(void) initwizardc() {
+	 PyObject *m, *d;
+	 SWIG_globals = SWIG_newvarlink();
+	 m = Py_InitModule("wizardc", wizardcMethods);
+	 d = PyModule_GetDict(m);
+	 PyDict_SetItemString(d,"wxWIZARD_EX_HELPBUTTON", PyInt_FromLong((long) wxWIZARD_EX_HELPBUTTON));
+	 PyDict_SetItemString(d,"wxEVT_WIZARD_PAGE_CHANGED", PyInt_FromLong((long) wxEVT_WIZARD_PAGE_CHANGED));
+	 PyDict_SetItemString(d,"wxEVT_WIZARD_PAGE_CHANGING", PyInt_FromLong((long) wxEVT_WIZARD_PAGE_CHANGING));
+	 PyDict_SetItemString(d,"wxEVT_WIZARD_CANCEL", PyInt_FromLong((long) wxEVT_WIZARD_CANCEL));
+	 PyDict_SetItemString(d,"wxEVT_WIZARD_HELP", PyInt_FromLong((long) wxEVT_WIZARD_HELP));
+{
+   int i;
+   for (i = 0; _swig_mapping[i].n1; i++)
+        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
+}
+}
diff --git a/wxPython/src/msw/wizard.py b/wxPython/src/msw/wizard.py
new file mode 100644
index 0000000000..959bc00345
--- /dev/null
+++ b/wxPython/src/msw/wizard.py
@@ -0,0 +1,277 @@
+# This file was created automatically by SWIG.
+import wizardc
+
+from windows import *
+
+from misc import *
+
+from gdi import *
+
+from fonts import *
+
+from clip_dnd import *
+
+from frames import *
+
+from stattool import *
+
+from controls import *
+
+from events import *
+
+# wizard events
+def EVT_WIZARD_PAGE_CHANGED(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_PAGE_CHANGED, func)
+
+def EVT_WIZARD_PAGE_CHANGING(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_PAGE_CHANGING, func)
+
+def EVT_WIZARD_CANCEL(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_CANCEL, func)
+
+def EVT_WIZARD_HELP(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_HELP, func)
+
+
+class wxWizardEventPtr(wxNotifyEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetDirection(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardEvent_GetDirection,(self,) + _args, _kwargs)
+        return val
+    def GetPage(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardEvent_GetPage,(self,) + _args, _kwargs)
+        if val: val = wxWizardPagePtr(val) 
+        return val
+    def __repr__(self):
+        return "<C wxWizardEvent instance at %s>" % (self.this,)
+class wxWizardEvent(wxWizardEventPtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(wizardc.new_wxWizardEvent,_args,_kwargs)
+        self.thisown = 1
+
+
+
+
+class wxWizardPagePtr(wxPanelPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Create(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPage_Create,(self,) + _args, _kwargs)
+        return val
+    def Init(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPage_Init,(self,) + _args, _kwargs)
+        return val
+    def GetPrev(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPage_GetPrev,(self,) + _args, _kwargs)
+        if val: val = wxWizardPagePtr(val) 
+        return val
+    def GetNext(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPage_GetNext,(self,) + _args, _kwargs)
+        if val: val = wxWizardPagePtr(val) 
+        return val
+    def GetBitmap(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPage_GetBitmap,(self,) + _args, _kwargs)
+        if val: val = wxBitmapPtr(val) ; val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxWizardPage instance at %s>" % (self.this,)
+class wxWizardPage(wxWizardPagePtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxPyWizardPagePtr(wxWizardPagePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Create(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_Create,(self,) + _args, _kwargs)
+        return val
+    def _setCallbackInfo(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage__setCallbackInfo,(self,) + _args, _kwargs)
+        return val
+    def base_DoMoveWindow(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoMoveWindow,(self,) + _args, _kwargs)
+        return val
+    def base_DoSetSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoSetSize,(self,) + _args, _kwargs)
+        return val
+    def base_DoSetClientSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoSetClientSize,(self,) + _args, _kwargs)
+        return val
+    def base_DoSetVirtualSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoSetVirtualSize,(self,) + _args, _kwargs)
+        return val
+    def base_DoGetSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoGetSize,(self,) + _args, _kwargs)
+        return val
+    def base_DoGetClientSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoGetClientSize,(self,) + _args, _kwargs)
+        return val
+    def base_DoGetPosition(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoGetPosition,(self,) + _args, _kwargs)
+        return val
+    def base_DoGetVirtualSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoGetVirtualSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
+        return val
+    def base_DoGetBestSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_DoGetBestSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
+        return val
+    def base_InitDialog(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_InitDialog,(self,) + _args, _kwargs)
+        return val
+    def base_TransferDataToWindow(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_TransferDataToWindow,(self,) + _args, _kwargs)
+        return val
+    def base_TransferDataFromWindow(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_TransferDataFromWindow,(self,) + _args, _kwargs)
+        return val
+    def base_Validate(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_Validate,(self,) + _args, _kwargs)
+        return val
+    def base_AcceptsFocus(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_AcceptsFocus,(self,) + _args, _kwargs)
+        return val
+    def base_AcceptsFocusFromKeyboard(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_AcceptsFocusFromKeyboard,(self,) + _args, _kwargs)
+        return val
+    def base_GetMaxSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_GetMaxSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
+        return val
+    def base_AddChild(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_AddChild,(self,) + _args, _kwargs)
+        return val
+    def base_RemoveChild(self, *_args, **_kwargs):
+        val = apply(wizardc.wxPyWizardPage_base_RemoveChild,(self,) + _args, _kwargs)
+        return val
+    def __repr__(self):
+        return "<C wxPyWizardPage instance at %s>" % (self.this,)
+class wxPyWizardPage(wxPyWizardPagePtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(wizardc.new_wxPyWizardPage,_args,_kwargs)
+        self.thisown = 1
+        self._setCallbackInfo(self, wxPyWizardPage)
+        self._setOORInfo(self)
+
+
+
+def wxPrePyWizardPage(*_args,**_kwargs):
+    val = wxPyWizardPagePtr(apply(wizardc.new_wxPrePyWizardPage,_args,_kwargs))
+    val.thisown = 1
+    val._setOORInfo(val)
+    return val
+
+
+class wxWizardPageSimplePtr(wxWizardPagePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Create(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPageSimple_Create,(self,) + _args, _kwargs)
+        return val
+    def Init(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPageSimple_Init,(self,) + _args, _kwargs)
+        return val
+    def SetPrev(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPageSimple_SetPrev,(self,) + _args, _kwargs)
+        return val
+    def SetNext(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizardPageSimple_SetNext,(self,) + _args, _kwargs)
+        return val
+    def __repr__(self):
+        return "<C wxWizardPageSimple instance at %s>" % (self.this,)
+class wxWizardPageSimple(wxWizardPageSimplePtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(wizardc.new_wxWizardPageSimple,_args,_kwargs)
+        self.thisown = 1
+        self._setOORInfo(self)
+
+
+
+def wxPreWizardPageSimple(*_args,**_kwargs):
+    val = wxWizardPageSimplePtr(apply(wizardc.new_wxPreWizardPageSimple,_args,_kwargs))
+    val.thisown = 1
+    val._setOORInfo(val)
+    return val
+
+
+class wxWizardPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Create(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_Create,(self,) + _args, _kwargs)
+        return val
+    def Init(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_Init,(self,) + _args, _kwargs)
+        return val
+    def RunWizard(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_RunWizard,(self,) + _args, _kwargs)
+        return val
+    def GetCurrentPage(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_GetCurrentPage,(self,) + _args, _kwargs)
+        if val: val = wxWizardPagePtr(val) 
+        return val
+    def SetPageSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_SetPageSize,(self,) + _args, _kwargs)
+        return val
+    def GetPageSize(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_GetPageSize,(self,) + _args, _kwargs)
+        if val: val = wxSizePtr(val) ; val.thisown = 1
+        return val
+    def FitToPage(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_FitToPage,(self,) + _args, _kwargs)
+        return val
+    def IsRunning(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_IsRunning,(self,) + _args, _kwargs)
+        return val
+    def ShowPage(self, *_args, **_kwargs):
+        val = apply(wizardc.wxWizard_ShowPage,(self,) + _args, _kwargs)
+        return val
+    def __repr__(self):
+        return "<C wxWizard instance at %s>" % (self.this,)
+class wxWizard(wxWizardPtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(wizardc.new_wxWizard,_args,_kwargs)
+        self.thisown = 1
+        self._setOORInfo(self)
+
+
+
+def wxPreWizard(*_args,**_kwargs):
+    val = wxWizardPtr(apply(wizardc.new_wxPreWizard,_args,_kwargs))
+    val.thisown = 1
+    val._setOORInfo(val)
+    return val
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+wxWizardPageSimple_Chain = wizardc.wxWizardPageSimple_Chain
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxWIZARD_EX_HELPBUTTON = wizardc.wxWIZARD_EX_HELPBUTTON
+wxEVT_WIZARD_PAGE_CHANGED = wizardc.wxEVT_WIZARD_PAGE_CHANGED
+wxEVT_WIZARD_PAGE_CHANGING = wizardc.wxEVT_WIZARD_PAGE_CHANGING
+wxEVT_WIZARD_CANCEL = wizardc.wxEVT_WIZARD_CANCEL
+wxEVT_WIZARD_HELP = wizardc.wxEVT_WIZARD_HELP
+
+
+#-------------- USER INCLUDE -----------------------
+
+# Stuff these names into the wx namespace so wxPyConstructObject can find them
+import wx
+wx.wxWizardEventPtr         = wxWizardEventPtr
diff --git a/wxPython/src/wizard.i b/wxPython/src/wizard.i
new file mode 100644
index 0000000000..5a1e4dbdca
--- /dev/null
+++ b/wxPython/src/wizard.i
@@ -0,0 +1,352 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wizard.i
+// Purpose:     Classes for wxWizard and etc.
+//
+// Author:      Robin Dunn
+//
+// Created:     16-Aug-2002
+// RCS-ID:      $Id$
+// Copyright:   (c) 2002 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module wizard
+
+%{
+#include "wxPython.h"
+#include <wx/wizard.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import windows.i
+%import frames.i
+%import misc.i
+%import controls.i
+
+
+//----------------------------------------------------------------------
+
+enum {
+    wxWIZARD_EX_HELPBUTTON,
+
+    wxEVT_WIZARD_PAGE_CHANGED,
+    wxEVT_WIZARD_PAGE_CHANGING,
+    wxEVT_WIZARD_CANCEL,
+    wxEVT_WIZARD_HELP
+};
+
+
+%pragma(python) code = "
+# wizard events
+def EVT_WIZARD_PAGE_CHANGED(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_PAGE_CHANGED, func)
+
+def EVT_WIZARD_PAGE_CHANGING(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_PAGE_CHANGING, func)
+
+def EVT_WIZARD_CANCEL(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_CANCEL, func)
+
+def EVT_WIZARD_HELP(win, id, func):
+    win.Connect(id, -1, wxEVT_WIZARD_HELP, func)
+
+"
+
+//----------------------------------------------------------------------
+
+class wxWizardEvent : public wxNotifyEvent
+{
+public:
+    wxWizardEvent(wxEventType type = wxEVT_NULL,
+                  int id = -1,
+                  bool direction = TRUE,
+                  wxWizardPage* page = NULL);
+
+    // for EVT_WIZARD_PAGE_CHANGING, return TRUE if we're going forward or
+    // FALSE otherwise and for EVT_WIZARD_PAGE_CHANGED return TRUE if we came
+    // from the previous page and FALSE if we returned from the next one
+    // (this function doesn't make sense for CANCEL events)
+    bool GetDirection() const { return m_direction; }
+
+    wxWizardPage*   GetPage() const { return m_page; }
+};
+
+
+//----------------------------------------------------------------------
+
+// wxWizardPage is one of the wizards screen: it must know what are the
+// following and preceding pages (which may be NULL for the first/last page).
+//
+// Other than GetNext/Prev() functions, wxWizardPage is just a panel and may be
+// used as such (i.e. controls may be placed directly on it &c).
+class wxWizardPage : public wxPanel
+{
+public:
+//     // ctor accepts an optional bitmap which will be used for this page instead
+//     // of the default one for this wizard (should be of the same size). Notice
+//     // that no other parameters are needed because the wizard will resize and
+//     // reposition the page anyhow
+//     wxWizardPage(wxWizard *parent,
+//                  const wxBitmap& bitmap = wxNullBitmap,
+//                  const char* resource = NULL);
+//     %name(wxPreWizardPage)wxWizardPage();
+
+    bool Create(wxWizard *parent,
+                const wxBitmap& bitmap = wxNullBitmap,
+                const char* resource = NULL);
+
+    // common part of ctors:
+    void Init();
+
+    // these functions are used by the wizard to show another page when the
+    // user chooses "Back" or "Next" button
+    virtual wxWizardPage *GetPrev() const;
+    virtual wxWizardPage *GetNext() const;
+
+    // default GetBitmap() will just return m_bitmap which is ok in 99% of
+    // cases - override this method if you want to create the bitmap to be used
+    // dynamically or to do something even more fancy. It's ok to return
+    // wxNullBitmap from here - the default one will be used then.
+    virtual wxBitmap GetBitmap() const;
+};
+
+
+
+%{  // C++ Version of a Python aware class
+class wxPyWizardPage : public wxWizardPage {
+    DECLARE_ABSTRACT_CLASS(wxPyWizardPage);
+public:
+    wxPyWizardPage() : wxWizardPage() {}
+    wxPyWizardPage(wxWizard *parent,
+                   const wxBitmap& bitmap = wxNullBitmap,
+                   const wxChar* resource = NULL)
+        : wxWizardPage(parent, bitmap, resource) {}
+
+    DEC_PYCALLBACK_WIZPG__pure(GetPrev);
+    DEC_PYCALLBACK_WIZPG__pure(GetNext);
+    DEC_PYCALLBACK_BITMAP__pure(GetBitmap);
+
+    DEC_PYCALLBACK_VOID_INT4(DoMoveWindow);
+    DEC_PYCALLBACK_VOID_INT5(DoSetSize);
+    DEC_PYCALLBACK_VOID_INTINT(DoSetClientSize);
+    DEC_PYCALLBACK_VOID_INTINT(DoSetVirtualSize);
+
+    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetSize);
+    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetClientSize);
+    DEC_PYCALLBACK_VOID_INTPINTP_const(DoGetPosition);
+
+    DEC_PYCALLBACK_SIZE_const(DoGetVirtualSize);
+    DEC_PYCALLBACK_SIZE_const(DoGetBestSize);
+
+    DEC_PYCALLBACK__(InitDialog);
+    DEC_PYCALLBACK_BOOL_(TransferDataFromWindow);
+    DEC_PYCALLBACK_BOOL_(TransferDataToWindow);
+    DEC_PYCALLBACK_BOOL_(Validate);
+
+    DEC_PYCALLBACK_BOOL_const(AcceptsFocus);
+    DEC_PYCALLBACK_BOOL_const(AcceptsFocusFromKeyboard);
+    DEC_PYCALLBACK_SIZE_const(GetMaxSize);
+
+    DEC_PYCALLBACK_VOID_WXWINBASE(AddChild);
+    DEC_PYCALLBACK_VOID_WXWINBASE(RemoveChild);
+
+    PYPRIVATE;
+};
+
+
+IMPLEMENT_ABSTRACT_CLASS(wxPyWizardPage, wxWizardPage);
+
+IMP_PYCALLBACK_WIZPG__pure(wxPyWizardPage, wxWizardPage, GetPrev);
+IMP_PYCALLBACK_WIZPG__pure(wxPyWizardPage, wxWizardPage, GetNext);
+IMP_PYCALLBACK_BITMAP__pure(wxPyWizardPage, wxWizardPage, GetBitmap);
+
+IMP_PYCALLBACK_VOID_INT4(wxPyWizardPage, wxWizardPage, DoMoveWindow);
+IMP_PYCALLBACK_VOID_INT5(wxPyWizardPage, wxWizardPage, DoSetSize);
+IMP_PYCALLBACK_VOID_INTINT(wxPyWizardPage, wxWizardPage, DoSetClientSize);
+IMP_PYCALLBACK_VOID_INTINT(wxPyWizardPage, wxWizardPage, DoSetVirtualSize);
+
+IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetSize);
+IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetClientSize);
+IMP_PYCALLBACK_VOID_INTPINTP_const(wxPyWizardPage, wxWizardPage, DoGetPosition);
+
+IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, DoGetVirtualSize);
+IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, DoGetBestSize);
+
+IMP_PYCALLBACK__(wxPyWizardPage, wxWizardPage, InitDialog);
+IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, TransferDataFromWindow);
+IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, TransferDataToWindow);
+IMP_PYCALLBACK_BOOL_(wxPyWizardPage, wxWizardPage, Validate);
+
+IMP_PYCALLBACK_BOOL_const(wxPyWizardPage, wxWizardPage, AcceptsFocus);
+IMP_PYCALLBACK_BOOL_const(wxPyWizardPage, wxWizardPage, AcceptsFocusFromKeyboard);
+IMP_PYCALLBACK_SIZE_const(wxPyWizardPage, wxWizardPage, GetMaxSize);
+
+IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWizardPage, wxWizardPage, AddChild);
+IMP_PYCALLBACK_VOID_WXWINBASE(wxPyWizardPage, wxWizardPage, RemoveChild);
+
+%}
+
+
+
+class wxPyWizardPage : public wxWizardPage {
+public:
+    // ctor accepts an optional bitmap which will be used for this page instead
+    // of the default one for this wizard (should be of the same size). Notice
+    // that no other parameters are needed because the wizard will resize and
+    // reposition the page anyhow
+    wxPyWizardPage(wxWizard *parent,
+                 const wxBitmap& bitmap = wxNullBitmap,
+                 const char* resource = NULL);
+    %name(wxPrePyWizardPage)wxPyWizardPage();
+
+    bool Create(wxWizard *parent,
+                const wxBitmap& bitmap = wxNullBitmap,
+                const char* resource = NULL);
+
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyWizardPage)"
+
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+    %pragma(python) addtomethod = "wxPrePyWizardPage:val._setOORInfo(val)"
+
+    void base_DoMoveWindow(int x, int y, int width, int height);
+    void base_DoSetSize(int x, int y, int width, int height,
+                        int sizeFlags = wxSIZE_AUTO);
+    void base_DoSetClientSize(int width, int height);
+    void base_DoSetVirtualSize( int x, int y );
+
+    void base_DoGetSize( int *OUTPUT, int *OUTPUT ) const;
+    void base_DoGetClientSize( int *OUTPUT, int *OUTPUT ) const;
+    void base_DoGetPosition( int *OUTPUT, int *OUTPUT ) const;
+
+    wxSize base_DoGetVirtualSize() const;
+    wxSize base_DoGetBestSize() const;
+
+    void base_InitDialog();
+    bool base_TransferDataToWindow();
+    bool base_TransferDataFromWindow();
+    bool base_Validate();
+
+    bool base_AcceptsFocus() const;
+    bool base_AcceptsFocusFromKeyboard() const;
+    wxSize base_GetMaxSize() const;
+
+    void base_AddChild(wxWindow* child);
+    void base_RemoveChild(wxWindow* child);
+};
+
+//----------------------------------------------------------------------
+
+
+// wxWizardPageSimple just returns the pointers given to the ctor and is useful
+// to create a simple wizard where the order of pages never changes.
+//
+// OTOH, it is also possible to dynamicly decide which page to return (i.e.
+// depending on the user's choices) as the wizard sample shows - in order to do
+// this, you must derive from wxWizardPage directly.
+class wxWizardPageSimple : public wxWizardPage
+{
+public:
+    // ctor takes the previous and next pages
+    wxWizardPageSimple(wxWizard *parent,
+                       wxWizardPage *prev = NULL,
+                       wxWizardPage *next = NULL,
+                       const wxBitmap& bitmap = wxNullBitmap,
+                       const wxChar* resource = NULL);
+    %name(wxPreWizardPageSimple)wxWizardPageSimple();
+
+    bool Create(wxWizard *parent = NULL,
+                wxWizardPage *prev = NULL,
+                wxWizardPage *next = NULL,
+                const wxBitmap& bitmap = wxNullBitmap,
+                const wxChar* resource = NULL);
+
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+    %pragma(python) addtomethod = "wxPreWizardPageSimple:val._setOORInfo(val)"
+
+    // common part of ctors:
+    void Init();
+
+    // the pointers may be also set later - but before starting the wizard
+    void SetPrev(wxWizardPage *prev);
+    void SetNext(wxWizardPage *next);
+
+    // a convenience function to make the pages follow each other
+    static void Chain(wxWizardPageSimple *first, wxWizardPageSimple *second);
+};
+
+
+//----------------------------------------------------------------------
+
+class  wxWizard : public wxDialog
+{
+public:
+    // ctor
+    wxWizard(wxWindow *parent,
+             int id = -1,
+             const wxString& title = wxEmptyString,
+             const wxBitmap& bitmap = wxNullBitmap,
+             const wxPoint& pos = wxDefaultPosition);
+    %name(wxPreWizard)wxWizard();
+
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+    %pragma(python) addtomethod = "wxPreWizard:val._setOORInfo(val)"
+
+    bool Create(wxWindow *parent,
+             int id = -1,
+             const wxString& title = wxEmptyString,
+             const wxBitmap& bitmap = wxNullBitmap,
+             const wxPoint& pos = wxDefaultPosition);
+
+    void Init();
+
+
+    // executes the wizard starting from the given page, returns TRUE if it was
+    // successfully finished, FALSE if user cancelled it
+    virtual bool RunWizard(wxWizardPage *firstPage);
+
+    // get the current page (NULL if RunWizard() isn't running)
+    virtual wxWizardPage *GetCurrentPage() const;
+
+    // set the min size which should be available for the pages: a
+    // wizard will take into account the size of the bitmap (if any)
+    // itself and will never be less than some predefined fixed size
+    virtual void SetPageSize(const wxSize& size);
+
+    // get the size available for the page: the wizards are not resizeable, so
+    // this size doesn't change
+    virtual wxSize GetPageSize() const;
+
+    // set the best size for the wizard, i.e. make it big enough to contain all
+    // of the pages starting from the given one
+    //
+    // this function may be called several times and possible with different
+    // pages in which case it will only increase the page size if needed (this
+    // may be useful if not all pages are accessible from the first one by
+    // default)
+    virtual void FitToPage(const wxWizardPage *firstPage);
+
+    // is the wizard running?
+    bool IsRunning() const { return m_page != NULL; }
+
+    // show the prev/next page, but call TransferDataFromWindow on the current
+    // page first and return FALSE without changing the page if
+    // TransferDataFromWindow() returns FALSE - otherwise, returns TRUE
+    bool ShowPage(wxWizardPage *page, bool goingForward = TRUE);
+};
+
+
+//----------------------------------------------------------------------
+//----------------------------------------------------------------------
+// This file gets appended to the shadow class file.
+//----------------------------------------------------------------------
+
+%pragma(python) include="_wizardextras.py";
+
+//---------------------------------------------------------------------------
-- 
2.45.2