This commit was manufactured by cvs2svn to create tag

'wxPython-0_5_4'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/wxPython-0_5_4@1552 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

utils/wxPython/.cvsignore

@@ -0,0 +1,97 @@
+*.zip
+.cvsignore
+.emacs.desktop
+__init__.py
+__init__.py
+__init__.pyc
+__init__.pyc
+__init__.pyo
+__init__.pyo
+cmndlgs.py
+cmndlgs.py
+cmndlgs.pyc
+cmndlgs.pyc
+cmndlgs.pyo
+cmndlgs.pyo
+controls.py
+controls.py
+controls.pyc
+controls.pyc
+controls.pyo
+controls.pyo
+controls2.py
+controls2.py
+controls2.pyc
+controls2.pyc
+controls2.pyo
+controls2.pyo
+events.py
+events.py
+events.pyc
+events.pyc
+events.pyo
+events.pyo
+frames.py
+frames.py
+frames.pyc
+frames.pyc
+frames.pyo
+frames.pyo
+gdi.py
+gdi.py
+gdi.pyc
+gdi.pyc
+gdi.pyo
+gdi.pyo
+mdi.py
+mdi.py
+mdi.pyc
+mdi.pyc
+mdi.pyo
+mdi.pyo
+misc.py
+misc.py
+misc.pyc
+misc.pyc
+misc.pyo
+misc.pyo
+stattool.py
+stattool.py
+stattool.pyc
+stattool.pyc
+stattool.pyo
+stattool.pyo
+utils.py
+utils.py
+utils.pyc
+utils.pyc
+utils.pyo
+windows.py
+windows.py
+windows.pyc
+windows.pyc
+windows.pyo
+windows.pyo
+windows2.py
+windows2.py
+windows2.pyc
+windows2.pyc
+windows2.pyo
+windows2.pyo
+windows3.py
+windows3.pyc
+windows3.pyo
+wx.py
+wx.py
+wx.pyc
+wx.pyc
+wx.pyo
+wxc.ilk
+wxc.pdb
+wxc.pyd
+wxp.py
+wxp.pyc
+wxp.pyo
+wxpc.ilk
+wxpc.pdb
+wxpc.pyd

utils/wxPython/README.txt

@@ -0,0 +1,204 @@
+wxPython README
+---------------
+
+Introduction
+------------
+The code in this subtree is a Python Extension Module that enables the
+use of wxWindows from the Python language.  So what is Python?  Go to
+http://www.python.org to learn more but in a nutshell, it's an
+extremly cool object oriented language.  It's easier than Perl and
+nearly as powerful.  It runs on more platforms than Java, and by some
+reports, is even faster than Java with a JIT compiler!
+
+So why would you want to use wxPython over just C++ and wxWindows?
+Personally I prefer using Python for everything.  I only use C++ when
+I absolutly have to eek more performance out of an algorithm, and even
+then I ususally code it as an extension module and leave the majority
+of the program in Python.  Another good thing to use wxPython for is
+quick prototyping of your wxWindows apps.  With C++ you have to
+continuously go though the edit-compile-link-run cycle, which can be
+quite time comsuming.  With Python it is only an edit-run cycle.  You
+can easily build an application in a few hours with Python that would
+normally take a few days with C++.  Converting a wxPython app to a
+C++/wxWindows app should be a straight forward task.
+
+This extension module attempts to mirror the class heiarchy of
+wxWindows as closely as possble.  This means that there is a wxFrame
+class in wxPython that looks, smells, tastes and acts almost the same
+as the wxFrame class in the C++ version.  Unfortunatly, I wasn't able
+to match things exactly because of differences in the languages, but
+the differences should be easy to absorb because they are natural to
+Python.  For example, some methods that return mutliple values via
+argument pointers in C++ will return a tuple of values in Python.
+These differences have not been documented yet so if something isn't
+working the same as described in the wxWindows documents the best
+thing to do is to scan through the wxPython sources, especially the .i
+files, as that is where the interfaces for wxPython are defined.
+
+Currently this extension module is designed such that the entire
+application will be written in Python.  I havn't tried it yet, but I
+am sure that attempting to embed wxPython in a C++ wxWindows
+application will cause problems.  However there is a plan to support
+this in the future.
+
+
+What's new in 0.5.3
+-------------------
+Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+
+Various cleanup, tweaks, minor additions, etc. to maintain
+compatibility with the current wxWindows.
+
+
+
+What's new in 0.5.0
+-------------------
+Changed the import semantics from "from wxPython import *" to "from
+wxPython.wx import *"  This is for people who are worried about
+namespace pollution, they can use "from wxPython import wx" and then
+prefix all the wxPython identifiers with "wx."
+
+Added wxTaskbarIcon for wxMSW.
+
+Made the events work for wxGrid.
+
+Added wxConfig.
+
+Added wxMiniFrame for wxGTK.
+
+Changed many of the args and return values that were pointers to gdi
+objects to references to reflect changes in the wxWindows API.
+
+Other assorted fixes and additions.
+
+
+
+
+What's new in 0.4.2
+-------------------
+
+wxPython on wxGTK works!!!  Both dynamic and static on Linux and
+static on Solaris have been tested.  Many thanks go to Harm
+<H.v.d.Heijden@phys.tue.nl> for his astute detective work on tracking
+down a nasty DECREF bug.  Okay so I have to confess that it was just a
+DSM (Dumb Stupid Mistake) on my part but it was nasty none the less
+because the behavior was so different on different platforms.
+
+
+The dynamicly loaded module on Solaris is still segfaulting, so it
+must have been a different issue all along...
+
+
+
+What's New in 0.4
+-----------------
+
+1. Worked on wxGTK compatibility.  It is partially working.  On a
+Solaris/Sparc box wxPython is working but only when it is statically
+linked with the Python interpreter.  When built as a dyamically loaded
+extension module, things start acting weirdly and it soon seg-faults.
+And on Linux both the statically linked and the dynamically linked
+version segfault shortly after starting up.
+
+2. Added Toolbar, StatusBar and SplitterWindow classes.
+
+3. Varioius bug fixes, enhancements, etc.
+
+
+
+Build Instructions
+------------------
+I used SWIG (http://www.swig.org) to create the source code for the
+extension module.  This enabled me to only have to deal with a small
+amount of code and only have to bother with the exceptional issues.
+SWIG takes care of the rest and generates all the repetative code for
+me.  You don't need SWIG to build the extension module as all the
+generated C++ code is included under the src directory.
+
+I added a few minor features to SWIG to control some of the code
+generation.  If you want to playaround with this the patches are in
+wxPython/SWIG.patches and they should be applied to the 1.1p5 version
+of SWIG.  These new patches are documented at
+http://starship.skyport.net/crew/robind/python/#swig, and they should
+also end up in the 1.2 version of SWIG.
+
+wxPython is organized as a Python package.  This means that the
+directory containing the results of the build process should be a
+subdirectory of a directory on the PYTHONPATH.  (And preferably should
+be named wxPython.)  You can control where the build process will dump
+wxPython by setting the TARGETDIR makefile variable.  The default is
+$(WXWIN)/utils/wxPython, where this README.txt is located.  If you
+leave it here then you should add $(WXWIN)/utils to your PYTHONPATH.
+However, you may prefer to use something that is already on your
+PYTHONPATH, such as the site-packages directory on Unix systems.
+
+
+Win32
+-----
+
+1. Build wxWindows with wxUSE_RESOURCE_LOADING_IN_MSW set to 1 in
+include/wx/msw/setup.h so icons can be loaded dynamically.  While
+there, make sure wxUSE_OWNER_DRAWN is also set to 1.
+
+2. Change into the $(WXWIN)/utils/wxPython/src directory.
+
+3. Edit makefile.nt and specify where your python installation is at.
+You may also want to fiddle with the TARGETDIR variable as described
+above.
+
+4. Run nmake -f makefile.nt
+
+5. If it builds successfully, congratulations!  Move on to the next
+step.  If not then you can try mailing me for help.  Also, I will
+always have a pre-built win32 version of this extension module at
+http://starship.skyport.net/crew/robind/python.
+
+6. Change to the $(WXWIN)/utils/wxPython/tests directory.
+
+7. Try executing the test programs.  Note that some of these print
+diagnositc or test info to standard output, so they will require the
+console version of python.  For example:
+
+    python test1.py
+
+To run them without requiring a console, you can use the pythonw.exe
+version of Python either from the command line or from a shortcut.
+
+
+
+Unix
+----
+
+1. Change into the $(WXWIN)/utils/wxPython/src directory.
+
+2. Edit Setup.in and ensure that the flags, directories, and toolkit
+options are correct.  See the above commentary about TARGETDIR.  There
+are a few sample Setup.in.[platform] files provided.
+
+3. Run this command to generate a makefile:
+
+    make -f Makefile.pre.in boot
+
+4. Run these commands to build and then install the wxPython extension
+module:
+
+    make
+    make install
+
+
+5. Change to the $(WXWIN)/utils/wxPython/tests directory.
+
+6. Try executing the test programs.  For example:
+
+    python test1.py
+
+
+
+------------------------
+10/20/1998
+
+Robin Dunn
+robin@alldunn.com
+
+
+

utils/wxPython/SWIG.patches/Include.patch

@@ -0,0 +1,97 @@
+*** swig.h.old	Wed Feb 04 14:59:40 1998
+--- swig.h	Fri Aug 28 14:46:32 1998
+***************
+*** 178,185 ****
+--- 178,211 ----
+    char  *firstkey();
+    char  *nextkey();
+  };
+  
++ // -------------------------------------------------------------------
++ // Simple Vector class
++ // User is responsible for deleting contents before deleteing Vector
++ // -------------------------------------------------------------------
++ 
++ class Vector {
++ public:
++     Vector(size_t allocSize=8);
++     ~Vector();
++ 
++     size_t size()                      { return m_size;  }
++     size_t count()                     { return m_count; }
++     size_t append(void* object);
++     size_t extend(size_t newSize);
++ 
++     void*& operator[] (size_t idx);
++ 
++     static void*    s_nullPtr;
++ 
++ private:
++     size_t          m_size;
++     size_t          m_count;
++     void**          m_data;
++ };
++ 
++ 
+  /************************************************************************
+   * class DataType
+   *
+   * Defines the basic datatypes supported by the translator.
+***************
+*** 684,691 ****
+--- 710,761 ----
+  extern char  *name_get(char *vname, int suppress=0);
+  extern char  *name_set(char *vname, int suppress=0);
+  extern char  *name_construct(char *classname, int suppress=0);
+  extern char  *name_destroy(char *classname, int suppress=0);
++ 
++ // ----------------------------------------------------------------------
++ // class CPP_class
++ //
++ // Class for managing class members (internally)
++ // ----------------------------------------------------------------------
++ 
++ class CPP_member;
++ 
++ class CPP_class {
++ public:
++   char        *classname;             // Real class name
++   char        *classrename;           // New name of class (if applicable)
++   char        *classtype;             // class type (struct, union, class)
++   int          strip;                 // Strip off class declarator
++   int          wextern;               // Value of extern wrapper variable for this class
++   int          have_constructor;      // Status bit indicating if we've seen a constructor
++   int          have_destructor;       // Status bit indicating if a destructor has been seen
++   int          is_abstract;           // Status bit indicating if this is an abstract class
++   int          generate_default;      // Generate default constructors
++   int          objective_c;           // Set if this is an objective C class
++   int          error;                 // Set if this class can't be generated
++   int          line;                  // Line number
++   char        **baseclass;            // Base classes (if any)
++   Hash        *local;                 // Hash table for local types
++   Hash        *scope;                 // Local scope hash table
++   DocEntry    *de;                    // Documentation entry of class
++   CPP_member  *members;               // Linked list of members
++   CPP_class   *next;                  // Next class
++   static CPP_class *classlist;        // List of all classes stored
++ 
++   Vector      addPragmas;
++ 
++   CPP_class(char *name, char *ctype);
++   void add_member(CPP_member *m);
++   CPP_member *search_member(char *name);
++   void inherit_decls(int mode);
++   void emit_decls();
++   static CPP_class *search(char *name);
++   void create_default();
++   static void create_all();
++ };
++ 
++ extern CPP_class     *current_class;
+  
+  /***********************************************************************
+   * -- Revision History
+   * $Log$
+   * Revision 1.1  1998/10/03 05:56:02  RD
+   * *** empty log message ***
+   *

utils/wxPython/SWIG.patches/Modules.patch

@@ -0,0 +1,136 @@
+*** python.cxx.old	Fri Jan 02 22:17:40 1998
+--- python.cxx	Fri Aug 28 14:49:18 1998
+***************
+*** 1679,1684 ****
+--- 1679,1701 ----
+  	      }
+  	    }
+  	  }
++         } else if (strcmp(cmd, "addtomethod") == 0) {
++             // parse value, expected to be in the form "methodName:line"
++             char* txtptr = strchr(value, ':');
++             if (txtptr) {
++                 // add name and line to a list in current_class
++                 *txtptr = 0;
++                 txtptr++;
++                 AddPragmaData* apData = new AddPragmaData(value, txtptr);
++                 current_class->addPragmas.append(apData);
++ 
++             } else {
++                 fprintf(stderr,"%s : Line %d. Malformed addtomethod pragma.  Should be \"methodName:text\"\n",
++                         input_file, line_number);
++             }
++         } else if (strcmp(cmd, "addtoclass") == 0) {
++                 AddPragmaData* apData = new AddPragmaData("__class__", value);
++                 current_class->addPragmas.append(apData);
+  	} else {
+  	  fprintf(stderr,"%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
+  	}
+*** python.h.old	Thu Jul 24 22:18:50 1997
+--- python.h	Fri Aug 28 14:46:08 1998
+***************
+*** 185,191 ****
+--- 185,203 ----
+    void cpp_class_decl(char *, char *,char *);
+    void pragma(char *, char *, char *);
+    void add_typedef(DataType *t, char *name);
++ 
++   void emitAddPragmas(String& output, char* name, char* spacing);
+  };
+  
+  #define PYSHADOW_MEMBER  0x2
++ 
++ struct AddPragmaData {
++     String      m_method;
++     String      m_text;
++ 
++     AddPragmaData(char* method, char* text)
++         : m_method(method),
++           m_text(text)
++         {}
++ };
+  
+*** pycpp.cxx.old	Fri Jan 02 20:23:22 1998
+--- pycpp.cxx	Fri Aug 28 16:01:46 1998
+***************
+*** 276,281 ****
+--- 276,282 ----
+        }
+      }
+      //    if ((t->type != T_VOID) || (t->is_pointer))
++     emitAddPragmas(*pyclass, realname, tab8);
+      *pyclass << tab8 << "return val\n";
+  
+      // Change the usage string to reflect our shadow class
+***************
+*** 394,399 ****
+--- 395,401 ----
+        }
+        *construct << ")\n";
+        *construct << tab8 << "self.thisown = 1\n";
++       emitAddPragmas(*construct, "__init__", tab8);
+        have_constructor = 1;
+      } else {
+  
+***************
+*** 494,502 ****
+      *pyclass << tab4 << "def __del__(self):\n"
+  	     << tab8 << "if self.thisown == 1 :\n"
+  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
+!     
+      have_destructor = 1;
+- 
+      if (doc_entry) {
+        doc_entry->usage = "";
+        doc_entry->usage << "del this";
+--- 496,503 ----
+      *pyclass << tab4 << "def __del__(self):\n"
+  	     << tab8 << "if self.thisown == 1 :\n"
+  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
+!     emitAddPragmas(*pyclass, "__del__", tab8);
+      have_destructor = 1;
+      if (doc_entry) {
+        doc_entry->usage = "";
+        doc_entry->usage << "del this";
+***************
+*** 552,557 ****
+--- 553,560 ----
+  	   << tab8 << "return \"<C " << class_name <<" instance>\"\n";
+  
+        classes << repr;
++       emitAddPragmas(classes, "__class__", tab4);
++ 
+      }
+  
+      // Now build the real class with a normal constructor
+***************
+*** 747,752 ****
+--- 750,777 ----
+    }
+  }
+  
++ // --------------------------------------------------------------------------------
++ // PYTHON::emitAddPragmas(String& output, char* name, char* spacing);
++ //
++ // Search the current_class->addPragmas vector for any text belonging to name.
++ // Append the text properly spcaed to the output string.
++ //
++ // --------------------------------------------------------------------------------
++ 
++ void PYTHON::emitAddPragmas(String& output, char* name, char* spacing)
++ {
++     AddPragmaData*      apData;
++     size_t              count;
++     int                 i;
++ 
++     count = current_class->addPragmas.count();
++     for (i=0; i<count; i++) {
++         apData = (AddPragmaData*)current_class->addPragmas[i];
++         if (strcmp(apData->m_method, name) == 0) {
++             output << spacing << apData->m_text << "\n";
++         }
++     }
++ }
+  
+  /*********************************************************************************
+   *

utils/wxPython/SWIG.patches/SWIG.patch

@@ -0,0 +1,488 @@
+*** cplus.cxx.old	Mon Feb 02 14:55:42 1998
+--- cplus.cxx	Fri Aug 28 12:02:50 1998
+***************
+*** 581,612 ****
+  // Class for managing class members (internally)
+  // ----------------------------------------------------------------------
+  
+  static char   *inherit_base_class = 0;
+  
+- class CPP_class {
+- public:
+-   char        *classname;             // Real class name
+-   char        *classrename;           // New name of class (if applicable)
+-   char        *classtype;             // class type (struct, union, class)
+-   int          strip;                 // Strip off class declarator
+-   int          wextern;               // Value of extern wrapper variable for this class
+-   int          have_constructor;      // Status bit indicating if we've seen a constructor
+-   int          have_destructor;       // Status bit indicating if a destructor has been seen
+-   int          is_abstract;           // Status bit indicating if this is an abstract class
+-   int          generate_default;      // Generate default constructors
+-   int          objective_c;           // Set if this is an objective C class
+-   int          error;                 // Set if this class can't be generated
+-   int          line;                  // Line number
+-   char        **baseclass;            // Base classes (if any)
+-   Hash        *local;                 // Hash table for local types
+-   Hash        *scope;                 // Local scope hash table
+-   DocEntry    *de;                    // Documentation entry of class
+-   CPP_member  *members;               // Linked list of members
+-   CPP_class   *next;                  // Next class
+-   static CPP_class *classlist;        // List of all classes stored
+  
+!   CPP_class(char *name, char *ctype) {
+      CPP_class *c;
+      classname = copy_string(name);
+      classtype = copy_string(ctype);
+      classrename = 0;
+--- 581,593 ----
+  // Class for managing class members (internally)
+  // ----------------------------------------------------------------------
+  
+  static char   *inherit_base_class = 0;
++ CPP_class *CPP_class::classlist = 0;
++ CPP_class     *current_class;
+  
+  
+! CPP_class::CPP_class(char *name, char *ctype) {
+    CPP_class *c;
+    classname = copy_string(name);
+    classtype = copy_string(ctype);
+    classrename = 0;
+***************
+*** 642,650 ****
+    // ------------------------------------------------------------------------------
+    // Add a new C++ member to this class
+    // ------------------------------------------------------------------------------
+  
+!   void add_member(CPP_member *m) {
+      CPP_member *cm;
+      
+      // Set base class where this was defined
+      if (inherit_base_class)          
+--- 623,631 ----
+  // ------------------------------------------------------------------------------
+  // Add a new C++ member to this class
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::add_member(CPP_member *m) {
+    CPP_member *cm;
+  
+    // Set base class where this was defined
+    if (inherit_base_class)
+***************
+*** 664,672 ****
+    // ------------------------------------------------------------------------------
+    // Search for a member with the given name. Returns the member on success, 0 on failure
+    // ------------------------------------------------------------------------------
+  
+!   CPP_member *search_member(char *name) {
+      CPP_member *m;
+      char *c;
+      m = members;
+      while (m) {
+--- 645,653 ----
+  // ------------------------------------------------------------------------------
+  // Search for a member with the given name. Returns the member on success, 0 on failure
+  // ------------------------------------------------------------------------------
+  
+! CPP_member *CPP_class::search_member(char *name) {
+    CPP_member *m;
+    char *c;
+    m = members;
+    while (m) {
+***************
+*** 680,688 ****
+    // ------------------------------------------------------------------------------
+    // Inherit.  Put all the declarations associated with this class into the current
+    // ------------------------------------------------------------------------------
+  
+!   void inherit_decls(int mode) {
+      CPP_member *m;
+      m = members;
+      while (m) {
+        inherit_base_class = m->base;
+--- 661,669 ----
+  // ------------------------------------------------------------------------------
+  // Inherit.  Put all the declarations associated with this class into the current
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::inherit_decls(int mode) {
+    CPP_member *m;
+    m = members;
+    while (m) {
+      inherit_base_class = m->base;
+***************
+*** 696,704 ****
+    // ------------------------------------------------------------------------------
+    // Emit all of the declarations associated with this class 
+    // ------------------------------------------------------------------------------
+  
+!   void emit_decls() {
+      CPP_member    *m = members;
+      int  last_scope = name_scope(0);
+      abstract = is_abstract;
+      while (m) {
+--- 677,685 ----
+  // ------------------------------------------------------------------------------
+  // Emit all of the declarations associated with this class
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::emit_decls() {
+    CPP_member    *m = members;
+    int  last_scope = name_scope(0);
+    abstract = is_abstract;
+    while (m) {
+***************
+*** 713,721 ****
+    // ------------------------------------------------------------------------------  
+    // Search for a given class in the list
+    // ------------------------------------------------------------------------------
+  
+!   static CPP_class *search(char *name) {
+      CPP_class *c;
+      c = classlist;
+      if (!name) return 0;
+      while (c) {
+--- 694,702 ----
+  // ------------------------------------------------------------------------------
+  // Search for a given class in the list
+  // ------------------------------------------------------------------------------
+  
+! CPP_class *CPP_class::search(char *name) {
+    CPP_class *c;
+    c = classlist;
+    if (!name) return 0;
+    while (c) {
+***************
+*** 729,737 ****
+    // Add default constructors and destructors
+    //
+    // ------------------------------------------------------------------------------
+  
+!   void create_default() {
+      if (!generate_default) return;
+      
+      // Try to generate a constructor if not available.
+  
+--- 710,718 ----
+  // Add default constructors and destructors
+  //
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::create_default() {
+    if (!generate_default) return;
+  
+    // Try to generate a constructor if not available.
+  
+***************
+*** 751,764 ****
+    // ------------------------------------------------------------------------------
+    // Dump *all* of the classes saved out to the various
+    // language modules (this does what cplus_close_class used to do)
+    // ------------------------------------------------------------------------------
+-   static void create_all();
+- };
+- 
+- CPP_class *CPP_class::classlist = 0;
+- static CPP_class     *current_class;
+- 
+  void CPP_class::create_all() {
+    CPP_class *c;
+    c = classlist;
+    while (c) {
+--- 732,739 ----
+*** vector.cxx.old	Fri Aug 28 14:23:16 1998
+--- vector.cxx	Fri Aug 28 14:46:52 1998
+***************
+*** 0 ****
+--- 1,182 ----
++ 
++ /*******************************************************************************
++  * Simplified Wrapper and Interface Generator  (SWIG)
++  *
++  * Dave Beazley
++  *
++  * Department of Computer Science        Theoretical Division (T-11)
++  * University of Utah                    Los Alamos National Laboratory
++  * Salt Lake City, Utah  84112           Los Alamos, New Mexico  87545
++  * beazley@cs.utah.edu                   beazley@lanl.gov
++  *
++  * Copyright (c) 1995-1997
++  * The University of Utah and the Regents of the University of California
++  * All Rights Reserved
++  *
++  * Permission is hereby granted, without written agreement and without
++  * license or royalty fees, to use, copy, modify, and distribute this
++  * software and its documentation for any purpose, provided that
++  * (1) The above copyright notice and the following two paragraphs
++  * appear in all copies of the source code and (2) redistributions
++  * including binaries reproduces these notices in the supporting
++  * documentation.   Substantial modifications to this software may be
++  * copyrighted by their authors and need not follow the licensing terms
++  * described here, provided that the new terms are clearly indicated in
++  * all files where they apply.
++  *
++  * IN NO EVENT SHALL THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, THE
++  * UNIVERSITY OF UTAH OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY
++  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
++  * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
++  * EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF
++  * THE POSSIBILITY OF SUCH DAMAGE.
++  *
++  * THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, AND THE UNIVERSITY OF UTAH
++  * SPECIFICALLY DISCLAIM ANY WARRANTIES,INCLUDING, BUT NOT LIMITED TO,
++  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
++  * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
++  * THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE,
++  * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
++  *
++  *******************************************************************************/
++ 
++ #include "internal.h"
++ 
++ /*******************************************************************************
++  * $Header$
++  *
++  * File : vector.cxx
++  *
++  * A very simple Vector class.  Allways assumes that memory allocations are
++  * successful.  Should be made more robust...
++  *
++  *******************************************************************************/
++ 
++ void* Vector::s_nullPtr = NULL;
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::Vector(size_t allocSize = 8)
++ //
++ // Constructor.  Creates a new Vector.
++ //
++ // Inputs : initial allocation size (optional)
++ //
++ // Output : New Vector object.
++ //
++ // Side Effects : None
++ // -----------------------------------------------------------------------------
++ 
++ Vector::Vector(size_t allocSize)
++     : m_size(allocSize),
++       m_count(0),
++       m_data(0)
++ {
++     if (m_size) {
++         m_data = new void*[m_size];
++         int i;
++         for (i=0; i<m_size;i++)
++             m_data[i] = 0;
++     }
++ }
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::~Vector
++ //
++ // Destructor.  Only cleans up the vector, not its contents!
++ //
++ // -----------------------------------------------------------------------------
++ 
++ 
++ Vector::~Vector() {
++     if (m_data) {
++         delete [] m_data;
++     }
++ 
++     m_data = 0;
++     m_size = m_count = 0;
++ }
++ 
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // size_t Vector::extend(size_t newSize)
++ //
++ // Extends the vector to at least newSize length.  Won't do anything if newSize
++ // is smaller than the current size of the vector.
++ //
++ // Returns the new allocated size.
++ //
++ // -----------------------------------------------------------------------------
++ 
++ #define GRANULARITY     16
++ 
++ size_t Vector::extend(size_t newSize) {
++ 
++     if (newSize > m_size) {
++         newSize = newSize + (GRANULARITY - (newSize % GRANULARITY));
++ 
++         void** temp = new void*[newSize];
++         memcpy(temp, m_data, m_size*sizeof(void*));
++ 
++         int i;
++         for (i=m_size; i<newSize; i++)
++             temp[i] = 0;
++ 
++         delete [] m_data;
++         m_data = temp;
++         m_size = newSize;
++     }
++     return m_size;
++ }
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::append(void* object)
++ //
++ // Appends the object pointer to vector at index m_count.  Increments m_count.
++ // Returns the new count.
++ // -----------------------------------------------------------------------------
++ 
++ size_t Vector::append(void* object) {
++     if (m_count >= m_size) {
++         extend(m_count + 1);
++     }
++ 
++     m_data[m_count] = object;
++     m_count += 1;
++ 
++     return m_count;
++ }
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::operator[] (size_t idx)
++ //
++ // Returns a reference to the void pointer at idx.  If idx is beyond the range
++ // of the vector, returns a reference to s_nullPtr.
++ //
++ // -----------------------------------------------------------------------------
++ 
++ void*& Vector::operator[] (size_t idx) {
++     if (idx >= m_size) {
++         s_nullPtr = 0;
++         return s_nullPtr;
++     }
++ 
++     return m_data[idx];
++ }
++ 
++ 
++ /***********************************************************************
++  *
++  * -- Revision History
++  * $Log$
++  * Revision 1.1  1998/10/03 05:56:03  RD
++  * *** empty log message ***
++  *
++  *
++  ***********************************************************************/
++ 
++ 
++ 
++ 
++ 
++ 
+*** makefile.msc.old	Mon Jun 23 15:15:32 1997
+--- makefile.msc	Fri Aug 28 10:21:58 1998
+***************
+*** 33,50 ****
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS)
+  LD_FLAGS    =  -VERBOSE
+  
+  
+  #
+--- 33,50 ----
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS) $(OTHERFLAGS)
+  LD_FLAGS    =  -VERBOSE
+  
+  
+  #
+*** makefile.bc.old	Sun Jan 04 12:49:24 1998
+--- makefile.bc	Fri Aug 28 14:42:58 1998
+***************
+*** 34,47 ****
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
+            emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj \
+            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
+            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+!           sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+--- 34,47 ----
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
+            emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj \
+            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
+            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+!           vector.cxx sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+*** Makefile.in.old	Wed May 28 22:56:56 1997
+--- Makefile.in	Fri Aug 28 14:43:36 1998
+***************
+*** 51,63 ****
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
+!           html.o latex.o cplus.o lang.o hash.o sstring.o wrapfunc.o getopt.o comment.o \
+            typemap.o naming.o
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIB      = ../libswig.a
+--- 51,63 ----
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
+!           html.o latex.o cplus.o lang.o hash.o vector.o sstring.o wrapfunc.o getopt.o comment.o \
+            typemap.o naming.o
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIB      = ../libswig.a

utils/wxPython/TODO.txt

@@ -0,0 +1,43 @@
+wxPython TODO List
+------------------
+
+These are the major tasks to be done on wxPython:
+
+1. Get it working for wxGTK.
+
+2. Figure out how to do embedding of wxPython in a wxWindows C++
+   application.
+
+    Actually, now that I think about it it might actually work.  We
+    just need to move some of the wxWindows initialization stuff out
+    of wxpcinit, ensure that __wxStart is not called and that a wxApp
+    is not created.  So this task becomes: Create a test case for
+    embedding wxPython in a C++ app.  Should also create some helper
+    functions for passing window objects into the Python code, etc.
+
+    Test this with M.
+
+
+3. Add significantly to the tests.
+
+4. Derived Python classes should have the ability to call the standard
+   On** methods in the base class.
+
+5. There are some virtual On** and other methods in wxWindows that
+   should end up being callbacks in derived python classes, but they
+   are not called via the standard event system.  Is there any way to
+   hook into these and call Python methods (if they exist in the
+   derived class) without having to derive a specialized C++ class?
+
+6. Add the Doc/View related classes
+
+7. Add the Printing related classes
+
+8. Document the differences (method signatures, new methods to
+   compensate for no overloading, etc.) between wxPython and wxWindows.
+
+9. Create some larger-scale sample application with wxPython to show
+   it can be done and the simplicity that it will provide...  Test
+   distribution with Freeze.
+
+

utils/wxPython/distrib/wxPython.rsp

@@ -0,0 +1,38 @@
+wxPython\*.pyd
+wxPython\*.pyc
+wxPython\*.pyo
+wxPython\*.py
+wxPython\*.txt
+
+wxPython\tests\*.py
+wxPython\tests\bitmaps
+
+
+wxPython\src\*.i
+wxPython\src\*.py
+wxPython\src\*.cpp
+wxPython\src\*.h
+wxPython\src\*.ico
+wxPython\src\*.def
+wxPython\src\*.rc
+wxPython\src\makefile.*
+wxPython\src\Makefile.pre.in
+wxPython\src\Setup.in
+
+wxPython\src\msw\*.cpp
+wxPython\src\msw\*.h
+wxPython\src\msw\*.py
+
+wxPython\src\gtk\*.cpp
+wxPython\src\gtk\*.h
+wxPython\src\gtk\*.py
+
+wxPython\src\motif\*.cpp
+wxPython\src\motif\*.h
+wxPython\src\motif\*.py
+
+wxPython\src\qt\*.cpp
+wxPython\src\qt\*.h
+wxPython\src\qt\*.py
+
+

utils/wxPython/distrib/zipit.bat

@@ -0,0 +1,8 @@
+
+@echo off
+
+rem cd %WXWIN%\utils
+
+zip -@ -r wxPython\wxPython-%1.zip < wxPython\distrib\wxPython.rsp
+
+cd -

utils/wxPython/src/.cvsignore

@@ -0,0 +1,26 @@
+.emacs.desktop
+Makefile
+Makefile.pre
+Setup
+Setup.save
+Setup.save
+config.c
+make.bat
+sedscript
+templates
+transfer.zip
+vc50.pdb
+vc60.pdb
+wxPython.001
+wxPython.dsp
+wxPython.dsw
+wxPython.ncb
+wxPython.opt
+wxc.exp
+wxc.lib
+wxc.res
+wxp.pch
+wxpc.exp
+wxpc.lib
+wxpc.res
+wxpc.res.save

utils/wxPython/src/Makefile.pre.in

@@ -0,0 +1,389 @@
+# Universal Unix Makefile for Python extensions
+# =============================================
+
+# Short Instructions
+# ------------------
+
+# 1. Build and install Python (1.5 or newer).
+# 2. "make -f Makefile.pre.in boot"
+# 3. "make"
+# You should now have a shared library.
+
+# Long Instructions
+# -----------------
+
+# Build *and install* the basic Python 1.5 distribution.  See the
+# Python README for instructions.  (This version of Makefile.pre.in
+# only withs with Python 1.5, alpha 3 or newer.)
+
+# Create a file Setup.in for your extension.  This file follows the
+# format of the Modules/Setup.in file; see the instructions there.
+# For a simple module called "spam" on file "spammodule.c", it can
+# contain a single line:
+#   spam spammodule.c
+# You can build as many modules as you want in the same directory --
+# just have a separate line for each of them in the Setup.in file.
+
+# If you want to build your extension as a shared library, insert a
+# line containing just the string
+#   *shared*
+# at the top of your Setup.in file.
+
+# Note that the build process copies Setup.in to Setup, and then works
+# with Setup.  It doesn't overwrite Setup when Setup.in is changed, so
+# while you're in the process of debugging your Setup.in file, you may
+# want to edit Setup instead, and copy it back to Setup.in later.
+# (All this is done so you can distribute your extension easily and
+# someone else can select the modules they actually want to build by
+# commenting out lines in the Setup file, without editing the
+# original.  Editing Setup is also used to specify nonstandard
+# locations for include or library files.)
+
+# Copy this file (Misc/Makefile.pre.in) to the directory containing
+# your extension.
+
+# Run "make -f Makefile.pre.in boot".  This creates Makefile
+# (producing Makefile.pre and sedscript as intermediate files) and
+# config.c, incorporating the values for sys.prefix, sys.exec_prefix
+# and sys.version from the installed Python binary.  For this to work,
+# the python binary must be on your path.  If this fails, try
+#   make -f Makefile.pre.in Makefile VERSION=1.5 installdir=<prefix>
+# where <prefix> is the prefix used to install Python for installdir
+# (and possibly similar for exec_installdir=<exec_prefix>).
+
+# Note: "make boot" implies "make clobber" -- it assumes that when you
+# bootstrap you may have changed platforms so it removes all previous
+# output files.
+
+# If you are building your extension as a shared library (your
+# Setup.in file starts with *shared*), run "make" or "make sharedmods"
+# to build the shared library files.  If you are building a statically
+# linked Python binary (the only solution of your platform doesn't
+# support shared libraries, and sometimes handy if you want to
+# distribute or install the resulting Python binary), run "make
+# python".
+
+# Note: Each time you edit Makefile.pre.in or Setup, you must run
+# "make Makefile" before running "make".
+
+# Hint: if you want to use VPATH, you can start in an empty
+# subdirectory and say (e.g.):
+#   make -f ../Makefile.pre.in boot srcdir=.. VPATH=..
+
+
+# === Bootstrap variables (edited through "make boot") ===
+
+# The prefix used by "make inclinstall libainstall" of core python
+installdir=	/usr/local
+
+# The exec_prefix used by the same
+exec_installdir=$(installdir)
+
+# Source directory and VPATH in case you want to use VPATH.
+# (You will have to edit these two lines yourself -- there is no
+# automatic support as the Makefile is not generated by
+# config.status.)
+srcdir=		.
+VPATH=		.
+
+# === Variables that you may want to customize (rarely) ===
+
+# (Static) build target
+TARGET=		python
+
+# Installed python binary (used only by boot target)
+PYTHON=		python
+
+# Add more -I and -D options here
+CFLAGS=		$(OPT) -I$(INCLUDEPY) -I$(EXECINCLUDEPY) $(DEFS)
+
+# These two variables can be set in Setup to merge extensions.
+# See example[23].
+BASELIB=
+BASESETUP=
+
+# === Variables set by makesetup ===
+
+MODOBJS=	_MODOBJS_
+MODLIBS=	_MODLIBS_
+
+# === Definitions added by makesetup ===
+
+# === Variables from configure (through sedscript) ===
+
+VERSION=	@VERSION@
+CC=		@CC@
+LINKCC=		@LINKCC@
+SGI_ABI=	@SGI_ABI@
+OPT=		@OPT@
+LDFLAGS=	@LDFLAGS@
+LDLAST=		@LDLAST@
+DEFS=		@DEFS@
+LIBS=		@LIBS@
+LIBM=		@LIBM@
+LIBC=		@LIBC@
+RANLIB=		@RANLIB@
+MACHDEP=	@MACHDEP@
+SO=		@SO@
+LDSHARED=	@LDSHARED@
+CCSHARED=	@CCSHARED@
+LINKFORSHARED=	@LINKFORSHARED@
+#@SET_CCC@
+
+# Install prefix for architecture-independent files
+prefix=		/usr/local
+
+# Install prefix for architecture-dependent files
+exec_prefix=	$(prefix)
+
+# === Fixed definitions ===
+
+# Shell used by make (some versions default to the login shell, which is bad)
+SHELL=		/bin/sh
+
+# Expanded directories
+BINDIR=		$(exec_installdir)/bin
+LIBDIR=		$(exec_prefix)/lib
+MANDIR=		$(installdir)/man
+INCLUDEDIR=	$(installdir)/include
+SCRIPTDIR=	$(prefix)/lib
+
+# Detailed destination directories
+BINLIBDEST=	$(LIBDIR)/python$(VERSION)
+LIBDEST=	$(SCRIPTDIR)/python$(VERSION)
+INCLUDEPY=	$(INCLUDEDIR)/python$(VERSION)
+EXECINCLUDEPY=	$(exec_installdir)/include/python$(VERSION)
+LIBP=		$(exec_installdir)/lib/python$(VERSION)
+DESTSHARED=	$(BINLIBDEST)/site-packages
+
+LIBPL=		$(LIBP)/config
+
+PYTHONLIBS=	$(LIBPL)/libpython$(VERSION).a
+
+MAKESETUP=	$(LIBPL)/makesetup
+MAKEFILE=	$(LIBPL)/Makefile
+CONFIGC=	$(LIBPL)/config.c
+CONFIGCIN=	$(LIBPL)/config.c.in
+SETUP=		$(LIBPL)/Setup
+
+SYSLIBS=	$(LIBM) $(LIBC)
+
+ADDOBJS=	$(LIBPL)/python.o config.o
+
+# Portable install script (configure doesn't always guess right)
+INSTALL=	$(LIBPL)/install-sh -c
+# Shared libraries must be installed with executable mode on some systems;
+# rather than figuring out exactly which, we always give them executable mode.
+# Also, making them read-only seems to be a good idea...
+INSTALL_SHARED=	${INSTALL} -m 555
+
+#---------------------------------------------------
+# Possibly change some definintions for C++
+ifdef MY_LDSHARED
+LDSHARED=$(MY_LDSHARED)
+endif
+ifdef MY_LINKCC
+LINKCC=$(MY_LINKCC)
+endif
+
+
+# === Fixed rules ===
+
+# Default target.  This builds shared libraries only
+default:	sharedmods
+
+# Build everything
+all:		static sharedmods
+
+# Build shared libraries from our extension modules
+sharedmods:	$(SHAREDMODS)
+
+# Build a static Python binary containing our extension modules
+static:		$(TARGET)
+$(TARGET):	$(ADDOBJS) lib.a $(PYTHONLIBS) Makefile $(BASELIB)
+		$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) \
+		 $(ADDOBJS) lib.a $(PYTHONLIBS) \
+		 $(LINKPATH) $(BASELIB) $(MODLIBS) $(LIBS) $(SYSLIBS) \
+		 -o $(TARGET) $(LDLAST)
+
+#------------------------------------------------------------------------
+#------------------------------------------------------------------------
+# This is a default version of the install target for wxPython.  It just
+# redirects to wxInstall below...
+
+install:	wxInstall
+
+#install:	sharedmods
+#		if test ! -d $(DESTSHARED) ; then \
+#			mkdir $(DESTSHARED) ; else true ; fi
+#		-for i in X $(SHAREDMODS); do \
+#			if test $$i != X; \
+#			then $(INSTALL_SHARED) $$i $(DESTSHARED)/$$i; \
+#			fi; \
+#		done
+
+
+# Build the library containing our extension modules
+lib.a:		$(MODOBJS)
+		-rm -f lib.a
+		ar cr lib.a $(MODOBJS)
+		-$(RANLIB) lib.a
+
+# This runs makesetup *twice* to use the BASESETUP definition from Setup
+config.c Makefile:	Makefile.pre Setup $(BASESETUP) $(MAKESETUP)
+		$(MAKESETUP) \
+		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
+		$(MAKE) -f Makefile do-it-again
+
+# Internal target to run makesetup for the second time
+do-it-again:
+		$(MAKESETUP) \
+		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
+
+# Make config.o from the config.c created by makesetup
+config.o:	config.c
+		$(CC) $(CFLAGS) -c config.c
+
+# Setup is copied from Setup.in *only* if it doesn't yet exist
+Setup:
+		cp Setup.in Setup
+
+# Make the intermediate Makefile.pre from Makefile.pre.in
+Makefile.pre: Makefile.pre.in sedscript
+		sed -f sedscript Makefile.pre.in >Makefile.pre
+
+# Shortcuts to make the sed arguments on one line
+P=prefix
+E=exec_prefix
+H=Generated automatically from Makefile.pre.in by sedscript.
+L=LINKFORSHARED
+
+# Make the sed script used to create Makefile.pre from Makefile.pre.in
+sedscript:	$(MAKEFILE)
+	sed -n \
+	 -e '1s/.*/1i\\/p' \
+	 -e '2s%.*%# $H%p' \
+	 -e '/^VERSION=/s/^VERSION=[ 	]*\(.*\)/s%@VERSION[@]%\1%/p' \
+	 -e '/^CC=/s/^CC=[ 	]*\(.*\)/s%@CC[@]%\1%/p' \
+	 -e '/^CCC=/s/^CCC=[ 	]*\(.*\)/s%#@SET_CCC[@]%CCC=\1%/p' \
+	 -e '/^LINKCC=/s/^LINKCC=[ 	]*\(.*\)/s%@LINKCC[@]%\1%/p' \
+	 -e '/^OPT=/s/^OPT=[ 	]*\(.*\)/s%@OPT[@]%\1%/p' \
+	 -e '/^LDFLAGS=/s/^LDFLAGS=[ 	]*\(.*\)/s%@LDFLAGS[@]%\1%/p' \
+	 -e '/^DEFS=/s/^DEFS=[ 	]*\(.*\)/s%@DEFS[@]%\1%/p' \
+	 -e '/^LIBS=/s/^LIBS=[ 	]*\(.*\)/s%@LIBS[@]%\1%/p' \
+	 -e '/^LIBM=/s/^LIBM=[ 	]*\(.*\)/s%@LIBM[@]%\1%/p' \
+	 -e '/^LIBC=/s/^LIBC=[ 	]*\(.*\)/s%@LIBC[@]%\1%/p' \
+	 -e '/^RANLIB=/s/^RANLIB=[ 	]*\(.*\)/s%@RANLIB[@]%\1%/p' \
+	 -e '/^MACHDEP=/s/^MACHDEP=[ 	]*\(.*\)/s%@MACHDEP[@]%\1%/p' \
+	 -e '/^SO=/s/^SO=[ 	]*\(.*\)/s%@SO[@]%\1%/p' \
+	 -e '/^LDSHARED=/s/^LDSHARED=[ 	]*\(.*\)/s%@LDSHARED[@]%\1%/p' \
+	 -e '/^CCSHARED=/s/^CCSHARED=[ 	]*\(.*\)/s%@CCSHARED[@]%\1%/p' \
+	 -e '/^$L=/s/^$L=[ 	]*\(.*\)/s%@$L[@]%\1%/p' \
+	 -e '/^$P=/s/^$P=\(.*\)/s%^$P=.*%$P=\1%/p' \
+	 -e '/^$E=/s/^$E=\(.*\)/s%^$E=.*%$E=\1%/p' \
+	 $(MAKEFILE) >sedscript
+	echo "/^#@SET_CCC@/d" >>sedscript
+	echo "/^installdir=/s%=.*%=	$(installdir)%" >>sedscript
+	echo "/^exec_installdir=/s%=.*%=$(exec_installdir)%" >>sedscript
+	echo "/^srcdir=/s%=.*%=		$(srcdir)%" >>sedscript
+	echo "/^VPATH=/s%=.*%=		$(VPATH)%" >>sedscript
+	echo "/^LINKPATH=/s%=.*%=	$(LINKPATH)%" >>sedscript
+	echo "/^BASELIB=/s%=.*%=	$(BASELIB)%" >>sedscript
+	echo "/^BASESETUP=/s%=.*%=	$(BASESETUP)%" >>sedscript
+
+# Bootstrap target
+boot:	clobber
+	VERSION=`$(PYTHON) -c "import sys; print sys.version[:3]"`; \
+	installdir=`$(PYTHON) -c "import sys; print sys.prefix"`; \
+	exec_installdir=`$(PYTHON) -c "import sys; print sys.exec_prefix"`; \
+	$(MAKE) -f Makefile.pre.in VPATH=$(VPATH) srcdir=$(srcdir) \
+		VERSION=$$VERSION \
+		installdir=$$installdir \
+		exec_installdir=$$exec_installdir \
+		Makefile
+
+# Handy target to remove intermediate files and backups
+clean:
+		-rm -f *.o *~
+
+# Handy target to remove everything that is easily regenerated
+clobber:	clean
+		-rm -f *.a tags TAGS config.c Makefile.pre $(TARGET) sedscript
+		-rm -f *.so *.sl so_locations
+
+
+# Handy target to remove everything you don't want to distribute
+distclean:	clobber
+		-rm -f Makefile Setup
+
+
+
+
+#------------------------------------------------------------------------
+#------------------------------------------------------------------------
+# Custom rules and dependencies added for wxPython
+#
+
+
+SWIGFLAGS=-c++ -shadow -python -dnone -D__WXGTK__
+
+
+PYMODULES = $(GENCODEDIR)/wx.py        $(GENCODEDIR)/events.py    \
+	    $(GENCODEDIR)/windows.py   $(GENCODEDIR)/misc.py      \
+	    $(GENCODEDIR)/gdi.py       $(GENCODEDIR)/mdi.py       \
+	    $(GENCODEDIR)/controls.py  $(GENCODEDIR)/controls2.py \
+            $(GENCODEDIR)/windows2.py  $(GENCODEDIR)/cmndlgs.py   \
+            $(GENCODEDIR)/frames.py    $(GENCODEDIR)/stattool.py   \
+	    $(GENCODEDIR)/utils.py     $(GENCODEDIR)/windows3.py  \
+	    __init__.py
+
+
+# Implicit rules to run SWIG
+$(GENCODEDIR)/%.cpp : %.i
+	swig $(SWIGFLAGS) -c -o $@ $<
+
+$(GENCODEDIR)/%.py : %.i
+	swig $(SWIGFLAGS) -c -o $@ $<
+
+
+# This one must leave out the -c flag so we define the whole rule
+$(GENCODEDIR)/wx.cpp $(GENCODEDIR)/wx.py : wx.i my_typemaps.i _defs.i _extras.py
+	swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
+
+
+# define some dependencies
+$(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py   : windows.i    my_typemaps.i _defs.i
+$(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py  : windows2.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py  : windows3.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py    : events.i     my_typemaps.i _defs.i
+$(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py      : misc.i       my_typemaps.i _defs.i
+$(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py       : gdi.i        my_typemaps.i _defs.i
+$(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py       : mdi.i        my_typemaps.i _defs.i
+$(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py  : controls.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i  my_typemaps.i _defs.i
+$(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py   : cmndlgs.i    my_typemaps.i _defs.i
+$(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py    : frames.i     my_typemaps.i _defs.i
+$(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py  : stattool.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/utils.cpp     $(GENCODEDIR)/utils.py     : utils.i      my_typemaps.i _defs.i
+
+$(GENCODEDIR)/helpers.cpp:
+	ln -s `pwd`/helpers.cpp $@
+
+
+wxInstall :	sharedmods $(PYMODULES)
+	if test ! -d $(TARGETDIR) ; then \
+		mkdir $(TARGETDIR) ; else true ; fi
+	if [ "$(SHAREDMODS)" != "" ]; then \
+		 chmod 755 $(SHAREDMODS); \
+		 cp $(SHAREDMODS) $(TARGETDIR); fi
+	-for i in $(PYMODULES); do \
+		cp $$i $(TARGETDIR); \
+	done
+	python $(LIBDEST)/compileall.py -l $(TARGETDIR)
+	python -O $(LIBDEST)/compileall.py -l $(TARGETDIR)
+
+
+lib : libwxPython.a
+
+libwxPython.a : lib.a
+	cp $< $@

utils/wxPython/src/Setup.in

@@ -0,0 +1,44 @@
+# This file gives the details of what is needed to build this extension
+# module so the Makefile can be created.
+
+###
+### This file should be created by configure.  Currently it is tweaked by hand.
+###
+
+*shared*
+
+CCC=c++
+WXWIN=../../..
+GENCODEDIR=gtk
+srcdir=$(GENCODEDIR)
+
+# Depending on how your Python was built, you may have to set this
+# value to use the C++ driver to link with instead of the default
+# C driver.  For example:
+MY_LDSHARED=$(CCC) -shared
+
+# Same as above, but for statically linking Python and wxPython together,
+# in other words, if you comment out the *shared* above.  If this is the
+# case then you should ensure that the main() function is Python's, not
+# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
+# to force this...
+MY_LINKCC=$(CCC)
+
+
+## Pick one of these, or set your own.  This is where the
+## wxPython module should be installed.  It should be a
+## subdirectory named wxPython.
+TARGETDIR=..
+#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
+
+
+wxc	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
+	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
+	frames.cpp stattool.cpp utils.cpp windows3.cpp \
+	# CFLAGS
+	-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
+	-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
+	#-D__WXDEBUG__ \
+	# LFLAGS
+	-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
+	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11

utils/wxPython/src/Setup.in.linux

@@ -0,0 +1,44 @@
+# This file gives the details of what is needed to build this extension
+# module so the Makefile can be created.
+
+###
+### This file should be created by configure.  Currently it is tweaked by hand.
+###
+
+*shared*
+
+CCC=c++
+WXWIN=../../..
+GENCODEDIR=gtk
+srcdir=$(GENCODEDIR)
+
+# Depending on how your Python was built, you may have to set this
+# value to use the C++ driver to link with instead of the default
+# C driver.  For example:
+MY_LDSHARED=$(CCC) -shared
+
+# Same as above, but for statically linking Python and wxPython together,
+# in other words, if you comment out the *shared* above.  If this is the
+# case then you should ensure that the main() function is Python's, not
+# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
+# to force this...
+MY_LINKCC=$(CCC)
+
+
+## Pick one of these, or set your own.  This is where the
+## wxPython module should be installed.  It should be a
+## subdirectory named wxPython.
+TARGETDIR=..
+#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
+
+
+wxc	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
+	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
+	frames.cpp stattool.cpp utils.cpp windows3.cpp \
+	# CFLAGS
+	-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
+	-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
+	#-D__WXDEBUG__ \
+	# LFLAGS
+	-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
+	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11

utils/wxPython/src/Setup.in.solaris

@@ -0,0 +1,45 @@
+# This file gives the details of what is needed to build this extension
+# module so the Makefile can be created.
+
+###
+### This file should be created by configure.  Currently it is tweaked by hand.
+###
+
+#*shared*
+
+CCC=c++
+WXWIN=../../..
+GENCODEDIR=gtk
+srcdir=$(GENCODEDIR)
+
+# Depending on how your Python was built, you may have to set this
+# value to use the C++ driver to link with instead of the default
+# C driver.  For example:
+#MY_LDSHARED=$(CCC) -shared
+
+# Same as above, but for statically linking Python and wxPython together,
+# in other words, if you comment out the *shared* above.  If this is the
+# case then you should ensure that the main() function is Python's, not
+# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
+# to force this...
+MY_LINKCC=$(CCC)
+
+
+## Pick one of these, or set your own.  This is where the
+## wxPython module should be installed.  It should be a
+## subdirectory named wxPython.
+TARGETDIR=..
+#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
+
+
+wxc 	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
+	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
+	frames.cpp stattool.cpp utils.cpp windows3.cpp \
+	# CFLAGS
+	-I. -I$(WXWIN)/include -I/usr/local/lib/glib/include -I$(WXWIN)/src \
+	-I/usr/X/include -DSWIG_GLOBAL -D__WXGTK__ \
+	#-D__WXDEBUG__ \
+	# LFLAGS
+	-L$(WXWIN)/lib/solaris2.6 -L/usr/X/lib \
+	-L/usr/local/lib/gcc-lib/sparc-sun-solaris2.6/2.8.1 \
+	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11 -lstdc++ -lgcc

utils/wxPython/src/__init__.py

@@ -0,0 +1,43 @@
+#----------------------------------------------------------------------------
+# Name:         __init__.py
+# Purpose:      The presence of this file turns this directory into a
+#               Python package.
+#
+# Author:       Robin Dunn
+#
+# Created:      8/8/98
+# RCS-ID:       $Id$
+# Copyright:    (c) 1998 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+
+#----------------------------------------------------------------------------
+#
+# $Log$
+# Revision 1.3  1998/12/15 20:41:12  RD
+# Changed the import semantics from "from wxPython import *" to "from
+# wxPython.wx import *"  This is for people who are worried about
+# namespace pollution, they can use "from wxPython import wx" and then
+# prefix all the wxPython identifiers with "wx."
+#
+# Added wxTaskbarIcon for wxMSW.
+#
+# Made the events work for wxGrid.
+#
+# Added wxConfig.
+#
+# Added wxMiniFrame for wxGTK, (untested.)
+#
+# Changed many of the args and return values that were pointers to gdi
+# objects to references to reflect changes in the wxWindows API.
+#
+# Other assorted fixes and additions.
+#
+# Revision 1.2  1998/10/07 07:34:32  RD
+# Version 0.4.1 for wxGTK
+#
+# Revision 1.1  1998/08/09 08:25:49  RD
+# Initial version
+#
+#

utils/wxPython/src/_defs.i

@@ -0,0 +1,763 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        _defs.i
+// Purpose:     Definitions and stuff
+//
+// Author:      Robin Dunn
+//
+// Created:     6/24/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+//---------------------------------------------------------------------------
+// Forward declares...
+
+class wxPyApp;
+class wxEvtHandler;
+class wxWindow;
+class wxFrame;
+class wxMiniFrame;
+class wxPanel;
+class wxDialog;
+class wxMenu;
+class wxPyMenu;
+class wxMenuBar;
+class wxMenuItem;
+class wxEvent;
+class wxSizeEvent;
+class wxCloseEvent;
+class wxCommandEvent;
+class wxScrollEvent;
+class wxMouseEvent;
+class wxKeyEvent;
+class wxMoveEvent;
+class wxPaintEvent;
+class wxEraseEvent;
+class wxFocusEvent;
+class wxActivateEvent;
+class wxInitDialogEvent;
+class wxMenuEvent;
+class wxShowEvent;
+class wxIconizeEvent;
+class wxMaximizeEvent;
+class wxJoystickEvent;
+class wxDropFilesEvent;
+class wxIdleEvent;
+class wxUpdateUIEvent;
+class wxSysColourChangedEvent;
+class wxSize;
+class wxRealPoint;
+class wxPoint;
+class wxRect;
+class wxBitmap;
+class wxMask;
+class wxIcon;
+class wxCursor;
+class wxFont;
+class wxColour;
+class wxPen;
+class wxBrush;
+class wxDC;
+class wxMemoryDC;
+class wxScreenDC;
+class wxClientDC;
+class wxPaintDC;
+class wxPostScriptDC;
+class wxPrinterDC;
+class wxMetaFileDC;
+class wxMDIParentFrame;
+class wxMDIChildFrame;
+class wxMDIClientWindow;
+class wxControl;
+class wxButton;
+class wxBitmapButton;
+class wxCheckBox;
+class wxChoice;
+class wxComboBox;
+class wxGauge;
+class wxStaticBox;
+class wxStaticText;
+class wxListBox;
+class wxTextCtrl;
+class wxScrollBar;
+class wxSpinButton;
+class wxStaticBitmap;
+class wxRadioBox;
+class wxRadioButton;
+class wxSlider;
+
+class wxPyTimer;
+class wxIndividualLayoutConstraint;
+class wxLayoutConstraints;
+class wxToolBar;
+class wxStatusBar;
+
+//---------------------------------------------------------------------------
+
+// some definitions for SWIG only
+typedef unsigned char   byte;
+typedef short int       WXTYPE;
+typedef int             wxWindowID;
+typedef unsigned int    uint;
+typedef signed   int    EBool;
+
+
+//---------------------------------------------------------------------------
+
+// General numeric #define's and etc.  Making them all enums makes SWIG use the
+// real macro when making the Python Int
+
+enum {
+    wxMAJOR_VERSION,
+    wxMINOR_VERSION,
+    wxRELEASE_NUMBER,
+
+    wxNOT_FOUND,
+
+    wxVSCROLL,
+    wxHSCROLL,
+    wxCAPTION,
+    wxDOUBLE_BORDER,
+    wxSUNKEN_BORDER,
+    wxRAISED_BORDER,
+    wxBORDER,
+    wxSIMPLE_BORDER,
+    wxSTATIC_BORDER,
+    wxTRANSPARENT_WINDOW,
+    wxNO_BORDER,
+    wxUSER_COLOURS,
+    wxNO_3D,
+//wxOVERRIDE_KEY_TRANSLATIONS,
+    wxTAB_TRAVERSAL,
+    wxHORIZONTAL,
+    wxVERTICAL,
+    wxBOTH,
+    wxCENTER_FRAME,
+    wxSTAY_ON_TOP,
+    wxICONIZE,
+    wxMINIMIZE,
+    wxMAXIMIZE,
+    wxTHICK_FRAME,
+    wxSYSTEM_MENU,
+    wxMINIMIZE_BOX,
+    wxMAXIMIZE_BOX,
+    wxTINY_CAPTION_HORIZ,
+    wxTINY_CAPTION_VERT,
+    wxRESIZE_BOX,
+    wxRESIZE_BORDER,
+    wxDIALOG_MODAL,
+    wxDIALOG_MODELESS,
+    wxDEFAULT_FRAME_STYLE,
+    wxDEFAULT_DIALOG_STYLE,
+
+    wxFRAME_TOOL_WINDOW,
+    wxCLIP_CHILDREN,
+
+    wxRETAINED,
+    wxBACKINGSTORE,
+    wxTB_3DBUTTONS,
+    wxTB_HORIZONTAL,
+    wxTB_VERTICAL,
+    wxTB_FLAT,
+    wxCOLOURED,
+    wxFIXED_LENGTH,
+    wxALIGN_LEFT,
+    wxALIGN_CENTER,
+    wxALIGN_CENTRE,
+    wxALIGN_RIGHT,
+    wxLB_NEEDED_SB,
+    wxLB_ALWAYS_SB,
+    wxLB_SORT,
+    wxLB_SINGLE,
+    wxLB_MULTIPLE,
+    wxLB_EXTENDED,
+    wxLB_OWNERDRAW,
+    wxLB_HSCROLL,
+    wxPROCESS_ENTER,
+    wxPASSWORD,
+    wxTE_PROCESS_ENTER,
+    wxTE_PASSWORD,
+    wxTE_READONLY,
+    wxTE_MULTILINE,
+    wxCB_SIMPLE,
+    wxCB_DROPDOWN,
+    wxCB_SORT,
+    wxCB_READONLY,
+    wxRA_HORIZONTAL,
+    wxRA_VERTICAL,
+    wxRB_GROUP,
+    wxGA_PROGRESSBAR,
+    wxGA_HORIZONTAL,
+    wxGA_VERTICAL,
+    wxSL_HORIZONTAL,
+    wxSL_VERTICAL,
+    wxSL_AUTOTICKS,
+    wxSL_LABELS,
+    wxSL_LEFT,
+    wxSL_TOP,
+    wxSL_RIGHT,
+    wxSL_BOTTOM,
+    wxSL_BOTH,
+    wxSL_SELRANGE,
+    wxSB_HORIZONTAL,
+    wxSB_VERTICAL,
+    wxBU_AUTODRAW,
+    wxBU_NOAUTODRAW,
+    wxTR_HAS_BUTTONS,
+    wxTR_EDIT_LABELS,
+    wxTR_LINES_AT_ROOT,
+    wxLC_ICON,
+    wxLC_SMALL_ICON,
+    wxLC_LIST,
+    wxLC_REPORT,
+    wxLC_ALIGN_TOP,
+    wxLC_ALIGN_LEFT,
+    wxLC_AUTOARRANGE,
+    wxLC_USER_TEXT,
+    wxLC_EDIT_LABELS,
+    wxLC_NO_HEADER,
+    wxLC_NO_SORT_HEADER,
+    wxLC_SINGLE_SEL,
+    wxLC_SORT_ASCENDING,
+    wxLC_SORT_DESCENDING,
+    wxLC_MASK_TYPE,
+    wxLC_MASK_ALIGN,
+    wxLC_MASK_SORT,
+    wxSP_VERTICAL,
+    wxSP_HORIZONTAL,
+    wxSP_ARROW_KEYS,
+    wxSP_WRAP,
+    wxSP_NOBORDER,
+    wxSP_3D,
+    wxSP_BORDER,
+    wxTAB_MULTILINE,
+    wxTAB_RIGHTJUSTIFY,
+    wxTAB_FIXEDWIDTH,
+    wxTAB_OWNERDRAW,
+//    wxSB_SIZEGRIP,
+    wxFLOOD_SURFACE,
+    wxFLOOD_BORDER,
+    wxODDEVEN_RULE,
+    wxWINDING_RULE,
+    wxTOOL_TOP,
+    wxTOOL_BOTTOM,
+    wxTOOL_LEFT,
+    wxTOOL_RIGHT,
+    wxOK,
+    wxYES_NO,
+    wxCANCEL,
+    wxYES,
+    wxNO,
+    wxICON_EXCLAMATION,
+    wxICON_HAND,
+    wxICON_QUESTION,
+    wxICON_INFORMATION,
+    wxICON_STOP,
+    wxICON_ASTERISK,
+    wxICON_MASK,
+    wxCENTRE,
+    wxCENTER,
+    wxSIZE_AUTO_WIDTH,
+    wxSIZE_AUTO_HEIGHT,
+    wxSIZE_AUTO,
+    wxSIZE_USE_EXISTING,
+    wxSIZE_ALLOW_MINUS_ONE,
+#ifndef __WXGTK__
+    wxDF_TEXT,
+    wxDF_BITMAP,
+    wxDF_METAFILE,
+    wxDF_DIB,
+    wxDF_OEMTEXT,
+    wxDF_FILENAME,
+#endif
+    wxPORTRAIT,
+    wxLANDSCAPE,
+    wxID_OPEN,
+    wxID_CLOSE,
+    wxID_NEW,
+    wxID_SAVE,
+    wxID_SAVEAS,
+    wxID_REVERT,
+    wxID_EXIT,
+    wxID_UNDO,
+    wxID_REDO,
+    wxID_HELP,
+    wxID_PRINT,
+    wxID_PRINT_SETUP,
+    wxID_PREVIEW,
+    wxID_ABOUT,
+    wxID_HELP_CONTENTS,
+    wxID_HELP_COMMANDS,
+    wxID_HELP_PROCEDURES,
+    wxID_HELP_CONTEXT,
+    wxID_CUT,
+    wxID_COPY,
+    wxID_PASTE,
+    wxID_CLEAR,
+    wxID_FIND,
+    wxID_FILE1,
+    wxID_FILE2,
+    wxID_FILE3,
+    wxID_FILE4,
+    wxID_FILE5,
+    wxID_FILE6,
+    wxID_FILE7,
+    wxID_FILE8,
+    wxID_FILE9,
+    wxID_OK,
+    wxID_CANCEL,
+    wxID_APPLY,
+    wxID_YES,
+    wxID_NO,
+    wxBITMAP_TYPE_BMP,
+    wxBITMAP_TYPE_BMP_RESOURCE,
+    wxBITMAP_TYPE_ICO,
+    wxBITMAP_TYPE_ICO_RESOURCE,
+    wxBITMAP_TYPE_CUR,
+    wxBITMAP_TYPE_CUR_RESOURCE,
+    wxBITMAP_TYPE_XBM,
+    wxBITMAP_TYPE_XBM_DATA,
+    wxBITMAP_TYPE_XPM,
+    wxBITMAP_TYPE_XPM_DATA,
+    wxBITMAP_TYPE_TIF,
+    wxBITMAP_TYPE_TIF_RESOURCE,
+    wxBITMAP_TYPE_GIF,
+    wxBITMAP_TYPE_GIF_RESOURCE,
+    wxBITMAP_TYPE_PNG,
+    wxBITMAP_TYPE_PNG_RESOURCE,
+    wxBITMAP_TYPE_ANY,
+    wxBITMAP_TYPE_RESOURCE,
+
+    wxOPEN,
+    wxSAVE,
+    wxHIDE_READONLY,
+    wxOVERWRITE_PROMPT,
+
+    wxACCEL_ALT,
+    wxACCEL_CTRL,
+    wxACCEL_SHIFT,
+};
+
+
+/// Standard error codes
+enum  ErrCode
+{
+  ERR_PARAM = (-4000),
+  ERR_NODATA,
+  ERR_CANCEL,
+  ERR_SUCCESS = 0
+};
+
+
+enum {
+  wxDEFAULT ,
+  wxDECORATIVE,
+  wxROMAN,
+  wxSCRIPT,
+  wxSWISS,
+  wxMODERN,
+  wxTELETYPE,
+  wxVARIABLE,
+  wxFIXED,
+  wxNORMAL,
+  wxLIGHT,
+  wxBOLD,
+  wxITALIC,
+  wxSLANT,
+  wxSOLID,
+  wxDOT,
+  wxLONG_DASH,
+  wxSHORT_DASH,
+  wxDOT_DASH,
+  wxUSER_DASH,
+  wxTRANSPARENT,
+  wxSTIPPLE,
+  wxBDIAGONAL_HATCH,
+  wxCROSSDIAG_HATCH,
+  wxFDIAGONAL_HATCH,
+  wxCROSS_HATCH,
+  wxHORIZONTAL_HATCH,
+  wxVERTICAL_HATCH,
+  wxJOIN_BEVEL,
+  wxJOIN_MITER,
+  wxJOIN_ROUND,
+  wxCAP_ROUND,
+  wxCAP_PROJECTING,
+  wxCAP_BUTT
+};
+
+typedef enum {
+  wxCLEAR,      // 0
+  wxXOR,        // src XOR dst
+  wxINVERT,     // NOT dst
+  wxOR_REVERSE, // src OR (NOT dst)
+  wxAND_REVERSE,// src AND (NOT dst)
+  wxCOPY,       // src
+  wxAND,        // src AND dst
+  wxAND_INVERT, // (NOT src) AND dst
+  wxNO_OP,      // dst
+  wxNOR,        // (NOT src) AND (NOT dst)
+  wxEQUIV,      // (NOT src) XOR dst
+  wxSRC_INVERT, // (NOT src)
+  wxOR_INVERT,  // (NOT src) OR dst
+  wxNAND,       // (NOT src) OR (NOT dst)
+  wxOR,         // src OR dst
+  wxSET,        // 1
+  wxSRC_OR,     // source _bitmap_ OR destination
+  wxSRC_AND     // source _bitmap_ AND destination
+} form_ops_t;
+
+enum _Virtual_keycodes {
+ WXK_BACK    =   8,
+ WXK_TAB     =   9,
+ WXK_RETURN  =	13,
+ WXK_ESCAPE  =	27,
+ WXK_SPACE   =	32,
+ WXK_DELETE  = 127,
+
+ WXK_START   = 300,
+ WXK_LBUTTON,
+ WXK_RBUTTON,
+ WXK_CANCEL,
+ WXK_MBUTTON,
+ WXK_CLEAR,
+ WXK_SHIFT,
+ WXK_CONTROL,
+ WXK_MENU,
+ WXK_PAUSE,
+ WXK_CAPITAL,
+ WXK_PRIOR,  // Page up
+ WXK_NEXT,   // Page down
+ WXK_END,
+ WXK_HOME,
+ WXK_LEFT,
+ WXK_UP,
+ WXK_RIGHT,
+ WXK_DOWN,
+ WXK_SELECT,
+ WXK_PRINT,
+ WXK_EXECUTE,
+ WXK_SNAPSHOT,
+ WXK_INSERT,
+ WXK_HELP,
+ WXK_NUMPAD0,
+ WXK_NUMPAD1,
+ WXK_NUMPAD2,
+ WXK_NUMPAD3,
+ WXK_NUMPAD4,
+ WXK_NUMPAD5,
+ WXK_NUMPAD6,
+ WXK_NUMPAD7,
+ WXK_NUMPAD8,
+ WXK_NUMPAD9,
+ WXK_MULTIPLY,
+ WXK_ADD,
+ WXK_SEPARATOR,
+ WXK_SUBTRACT,
+ WXK_DECIMAL,
+ WXK_DIVIDE,
+ WXK_F1,
+ WXK_F2,
+ WXK_F3,
+ WXK_F4,
+ WXK_F5,
+ WXK_F6,
+ WXK_F7,
+ WXK_F8,
+ WXK_F9,
+ WXK_F10,
+ WXK_F11,
+ WXK_F12,
+ WXK_F13,
+ WXK_F14,
+ WXK_F15,
+ WXK_F16,
+ WXK_F17,
+ WXK_F18,
+ WXK_F19,
+ WXK_F20,
+ WXK_F21,
+ WXK_F22,
+ WXK_F23,
+ WXK_F24,
+ WXK_NUMLOCK,
+ WXK_SCROLL,
+ WXK_PAGEUP,
+ WXK_PAGEDOWN
+};
+
+typedef enum {
+ wxCURSOR_NONE = 0,
+ wxCURSOR_ARROW =  1,
+ wxCURSOR_BULLSEYE,
+ wxCURSOR_CHAR,
+ wxCURSOR_CROSS,
+ wxCURSOR_HAND,
+ wxCURSOR_IBEAM,
+ wxCURSOR_LEFT_BUTTON,
+ wxCURSOR_MAGNIFIER,
+ wxCURSOR_MIDDLE_BUTTON,
+ wxCURSOR_NO_ENTRY,
+ wxCURSOR_PAINT_BRUSH,
+ wxCURSOR_PENCIL,
+ wxCURSOR_POINT_LEFT,
+ wxCURSOR_POINT_RIGHT,
+ wxCURSOR_QUESTION_ARROW,
+ wxCURSOR_RIGHT_BUTTON,
+ wxCURSOR_SIZENESW,
+ wxCURSOR_SIZENS,
+ wxCURSOR_SIZENWSE,
+ wxCURSOR_SIZEWE,
+ wxCURSOR_SIZING,
+ wxCURSOR_SPRAYCAN,
+ wxCURSOR_WAIT,
+ wxCURSOR_WATCH,
+ wxCURSOR_BLANK
+//  #ifndef __WXMSW__
+//    /* Not yet implemented for Windows */
+//    , wxCURSOR_CROSS_REVERSE,
+//    wxCURSOR_DOUBLE_ARROW,
+//    wxCURSOR_BASED_ARROW_UP,
+//    wxCURSOR_BASED_ARROW_DOWN
+//  #endif
+} _standard_cursors_t;
+
+
+#define FALSE 0
+#define false 0
+#define TRUE 1
+#define true 1
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+
+/*
+ * Event types
+ *
+ */
+enum wxEventType {
+ wxEVT_NULL = 0,
+ wxEVT_FIRST = 10000,
+
+ // New names
+ wxEVT_COMMAND_BUTTON_CLICKED,
+ wxEVT_COMMAND_CHECKBOX_CLICKED,
+ wxEVT_COMMAND_CHOICE_SELECTED,
+ wxEVT_COMMAND_LISTBOX_SELECTED,
+ wxEVT_COMMAND_LISTBOX_DOUBLECLICKED,
+ wxEVT_COMMAND_CHECKLISTBOX_TOGGLED,
+ wxEVT_COMMAND_TEXT_UPDATED,
+ wxEVT_COMMAND_TEXT_ENTER,
+ wxEVT_COMMAND_MENU_SELECTED,
+ wxEVT_COMMAND_SLIDER_UPDATED,
+ wxEVT_COMMAND_RADIOBOX_SELECTED,
+ wxEVT_COMMAND_RADIOBUTTON_SELECTED,
+// wxEVT_COMMAND_SCROLLBAR_UPDATED is now obsolete since we use wxEVT_SCROLL... events
+ wxEVT_COMMAND_SCROLLBAR_UPDATED,
+ wxEVT_COMMAND_VLBOX_SELECTED,
+ wxEVT_COMMAND_COMBOBOX_SELECTED,
+ wxEVT_COMMAND_TOOL_CLICKED,
+ wxEVT_COMMAND_TOOL_RCLICKED,
+ wxEVT_COMMAND_TOOL_ENTER,
+ wxEVT_SET_FOCUS,
+ wxEVT_KILL_FOCUS,
+
+/* Mouse event types */
+ wxEVT_LEFT_DOWN,
+ wxEVT_LEFT_UP,
+ wxEVT_MIDDLE_DOWN,
+ wxEVT_MIDDLE_UP,
+ wxEVT_RIGHT_DOWN,
+ wxEVT_RIGHT_UP,
+ wxEVT_MOTION,
+ wxEVT_ENTER_WINDOW,
+ wxEVT_LEAVE_WINDOW,
+ wxEVT_LEFT_DCLICK,
+ wxEVT_MIDDLE_DCLICK,
+ wxEVT_RIGHT_DCLICK,
+
+ // Non-client mouse events
+ wxEVT_NC_LEFT_DOWN = wxEVT_FIRST + 100,
+ wxEVT_NC_LEFT_UP,
+ wxEVT_NC_MIDDLE_DOWN,
+ wxEVT_NC_MIDDLE_UP,
+ wxEVT_NC_RIGHT_DOWN,
+ wxEVT_NC_RIGHT_UP,
+ wxEVT_NC_MOTION,
+ wxEVT_NC_ENTER_WINDOW,
+ wxEVT_NC_LEAVE_WINDOW,
+ wxEVT_NC_LEFT_DCLICK,
+ wxEVT_NC_MIDDLE_DCLICK,
+ wxEVT_NC_RIGHT_DCLICK,
+
+/* Character input event type  */
+ wxEVT_CHAR,
+
+ /*
+  * Scrollbar event identifiers
+  */
+ wxEVT_SCROLL_TOP,
+ wxEVT_SCROLL_BOTTOM,
+ wxEVT_SCROLL_LINEUP,
+ wxEVT_SCROLL_LINEDOWN,
+ wxEVT_SCROLL_PAGEUP,
+ wxEVT_SCROLL_PAGEDOWN,
+ wxEVT_SCROLL_THUMBTRACK,
+
+ wxEVT_SIZE = wxEVT_FIRST + 200,
+ wxEVT_MOVE,
+ wxEVT_CLOSE_WINDOW,
+ wxEVT_END_SESSION,
+ wxEVT_QUERY_END_SESSION,
+ wxEVT_ACTIVATE_APP,
+ wxEVT_POWER,
+ wxEVT_CHAR_HOOK,
+ wxEVT_KEY_UP,
+ wxEVT_ACTIVATE,
+ wxEVT_CREATE,
+ wxEVT_DESTROY,
+ wxEVT_SHOW,
+ wxEVT_ICONIZE,
+ wxEVT_MAXIMIZE,
+ wxEVT_MOUSE_CAPTURE_CHANGED,
+ wxEVT_PAINT,
+ wxEVT_ERASE_BACKGROUND,
+ wxEVT_NC_PAINT,
+ wxEVT_PAINT_ICON,
+ wxEVT_MENU_CHAR,
+ wxEVT_MENU_INIT,
+ wxEVT_MENU_HIGHLIGHT,
+ wxEVT_POPUP_MENU_INIT,
+ wxEVT_CONTEXT_MENU,
+ wxEVT_SYS_COLOUR_CHANGED,
+ wxEVT_SETTING_CHANGED,
+ wxEVT_QUERY_NEW_PALETTE,
+ wxEVT_PALETTE_CHANGED,
+ wxEVT_JOY_BUTTON_DOWN,
+ wxEVT_JOY_BUTTON_UP,
+ wxEVT_JOY_MOVE,
+ wxEVT_JOY_ZMOVE,
+ wxEVT_DROP_FILES,
+ wxEVT_DRAW_ITEM,
+ wxEVT_MEASURE_ITEM,
+ wxEVT_COMPARE_ITEM,
+ wxEVT_INIT_DIALOG,
+ wxEVT_IDLE,
+ wxEVT_UPDATE_UI,
+
+ /* Generic command events */
+ // Note: a click is a higher-level event
+ // than button down/up
+ wxEVT_COMMAND_LEFT_CLICK,
+ wxEVT_COMMAND_LEFT_DCLICK,
+ wxEVT_COMMAND_RIGHT_CLICK,
+ wxEVT_COMMAND_RIGHT_DCLICK,
+ wxEVT_COMMAND_SET_FOCUS,
+ wxEVT_COMMAND_KILL_FOCUS,
+ wxEVT_COMMAND_ENTER,
+
+ /* Tree control event types */
+ wxEVT_COMMAND_TREE_BEGIN_DRAG,
+ wxEVT_COMMAND_TREE_BEGIN_RDRAG,
+ wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT,
+ wxEVT_COMMAND_TREE_END_LABEL_EDIT,
+ wxEVT_COMMAND_TREE_DELETE_ITEM,
+ wxEVT_COMMAND_TREE_GET_INFO,
+ wxEVT_COMMAND_TREE_SET_INFO,
+ wxEVT_COMMAND_TREE_ITEM_EXPANDED,
+ wxEVT_COMMAND_TREE_ITEM_EXPANDING,
+ wxEVT_COMMAND_TREE_ITEM_COLLAPSED,
+ wxEVT_COMMAND_TREE_ITEM_COLLAPSING,
+ wxEVT_COMMAND_TREE_SEL_CHANGED,
+ wxEVT_COMMAND_TREE_SEL_CHANGING,
+ wxEVT_COMMAND_TREE_KEY_DOWN,
+
+ /* List control event types */
+ wxEVT_COMMAND_LIST_BEGIN_DRAG,
+ wxEVT_COMMAND_LIST_BEGIN_RDRAG,
+ wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT,
+ wxEVT_COMMAND_LIST_END_LABEL_EDIT,
+ wxEVT_COMMAND_LIST_DELETE_ITEM,
+ wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS,
+ wxEVT_COMMAND_LIST_GET_INFO,
+ wxEVT_COMMAND_LIST_SET_INFO,
+ wxEVT_COMMAND_LIST_ITEM_SELECTED,
+ wxEVT_COMMAND_LIST_ITEM_DESELECTED,
+ wxEVT_COMMAND_LIST_KEY_DOWN,
+ wxEVT_COMMAND_LIST_INSERT_ITEM,
+ wxEVT_COMMAND_LIST_COL_CLICK,
+
+ /* Tab and notebook control event types */
+ wxEVT_COMMAND_TAB_SEL_CHANGED,
+ wxEVT_COMMAND_TAB_SEL_CHANGING,
+ wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
+ wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
+
+};
+
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.10  1999/01/30 07:30:08  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.9  1998/12/15 20:41:13  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.8  1998/11/15 23:03:42  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.7  1998/11/11 03:12:24  RD
+//
+// Additions for wxTreeCtrl
+//
+// Revision 1.6  1998/10/20 06:43:53  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.5  1998/10/02 06:40:32  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.4  1998/08/18 19:48:11  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.3  1998/08/14 23:36:33  RD
+// Beginings of wxGTK compatibility
+//
+// Revision 1.2  1998/08/14 03:16:35  RD
+// removed some definitions that got removed from defs.h
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//

utils/wxPython/src/_extras.py

@@ -0,0 +1,662 @@
+#----------------------------------------------------------------------------
+# Name:         _extra.py
+# Purpose:	This file is appended to the shadow class file generated
+#               by SWIG.  We add some unSWIGable things here.
+#
+# Author:       Robin Dunn
+#
+# Created:      6/30/97
+# RCS-ID:       $Id$
+# Copyright:    (c) 1998 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+import sys
+
+#----------------------------------------------------------------------
+# This gives this module's dictionary to the C++ extension code...
+
+_wxSetDictionary(vars())
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+# Helper function to link python methods to wxWindows virtual
+# functions by name.
+
+def _checkForCallback(obj, name, event, theID=-1):
+    try:    cb = getattr(obj, name)
+    except: pass
+    else:   obj.Connect(theID, -1, event, cb)
+
+def _StdWindowCallbacks(win):
+    _checkForCallback(win, "OnChar",               wxEVT_CHAR)
+    _checkForCallback(win, "OnSize",               wxEVT_SIZE)
+    _checkForCallback(win, "OnEraseBackground",    wxEVT_ERASE_BACKGROUND)
+    _checkForCallback(win, "OnSysColourChanged",   wxEVT_SYS_COLOUR_CHANGED)
+    _checkForCallback(win, "OnInitDialog",         wxEVT_INIT_DIALOG)
+    _checkForCallback(win, "OnIdle",               wxEVT_IDLE)
+    _checkForCallback(win, "OnPaint",              wxEVT_PAINT)
+
+def _StdFrameCallbacks(win):
+    _StdWindowCallbacks(win)
+    _checkForCallback(win, "OnActivate",           wxEVT_ACTIVATE)
+    _checkForCallback(win, "OnMenuHighlight",      wxEVT_MENU_HIGHLIGHT)
+    _checkForCallback(win, "OnCloseWindow",        wxEVT_CLOSE_WINDOW)
+
+
+def _StdDialogCallbacks(win):
+    _StdWindowCallbacks(win)
+    _checkForCallback(win, "OnOk",     wxEVT_COMMAND_BUTTON_CLICKED,   wxID_OK)
+    _checkForCallback(win, "OnApply",  wxEVT_COMMAND_BUTTON_CLICKED,   wxID_APPLY)
+    _checkForCallback(win, "OnCancel", wxEVT_COMMAND_BUTTON_CLICKED,   wxID_CANCEL)
+    _checkForCallback(win, "OnCloseWindow", wxEVT_CLOSE_WINDOW)
+    _checkForCallback(win, "OnCharHook",    wxEVT_CHAR_HOOK)
+
+
+def _StdOnScrollCallback(win):
+    try:    cb = getattr(win, "OnScroll")
+    except: pass
+    else:   EVT_SCROLL(win, cb)
+
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+# functions that look and act like the C++ Macros of the same name
+
+
+# Miscellaneous
+def EVT_SIZE(win, func):
+    win.Connect(-1, -1, wxEVT_SIZE, func)
+
+def EVT_MOVE(win, func):
+    win.Connect(-1, -1, wxEVT_MOVE, func)
+
+def EVT_CLOSE(win, func):
+    win.Connect(-1, -1, wxEVT_CLOSE_WINDOW, func)
+
+def EVT_PAINT(win, func):
+    win.Connect(-1, -1, wxEVT_PAINT, func)
+
+def EVT_ERASE_BACKGROUND(win, func):
+    win.Connect(-1, -1, wxEVT_ERASE_BACKGROUND, func)
+
+def EVT_CHAR(win, func):
+    win.Connect(-1, -1, wxEVT_CHAR, func)
+
+def EVT_CHAR_HOOK(win, func):
+    win.Connect(-1, -1, wxEVT_CHAR_HOOK, func)
+
+def EVT_MENU_HIGHLIGHT(win, id, func):
+    win.Connect(id, -1, wxEVT_MENU_HIGHLIGHT, func)
+
+def EVT_MENU_HIGHLIGHT_ALL(win, func):
+    win.Connect(-1, -1, wxEVT_MENU_HIGHLIGHT, func)
+
+def EVT_SET_FOCUS(win, func):
+    win.Connect(-1, -1, wxEVT_SET_FOCUS, func)
+
+def EVT_KILL_FOCUS(win, func):
+    win.Connect(-1, -1, wxEVT_KILL_FOCUS, func)
+
+def EVT_ACTIVATE(win, func):
+    win.Connect(-1, -1, wxEVT_ACTIVATE, func)
+
+def EVT_ACTIVATE_APP(win, func):
+    win.Connect(-1, -1, wxEVT_ACTIVATE_APP, func)
+
+def EVT_END_SESSION(win, func):
+    win.Connect(-1, -1, wxEVT_END_SESSION, func)
+
+def EVT_QUERY_END_SESSION(win, func):
+    win.Connect(-1, -1, wxEVT_QUERY_END_SESSION, func)
+
+def EVT_DROP_FILES(win, func):
+    win.Connect(-1, -1, wxEVT_DROP_FILES, func)
+
+def EVT_INIT_DIALOG(win, func):
+    win.Connect(-1, -1, wxEVT_INIT_DIALOG, func)
+
+def EVT_SYS_COLOUR_CHANGED(win, func):
+    win.Connect(-1, -1, wxEVT_SYS_COLOUR_CHANGED, func)
+
+def EVT_SHOW(win, func):
+    win.Connect(-1, -1, wxEVT_SHOW, func)
+
+def EVT_MAXIMIZE(win, func):
+    win.Connect(-1, -1, wxEVT_MAXIMIZE, func)
+
+def EVT_ICONIZE(win, func):
+    win.Connect(-1, -1, wxEVT_ICONIZE, func)
+
+def EVT_NAVIGATION_KEY(win, func):
+    win.Connect(-1, -1, wxEVT_NAVIGATION_KEY, func)
+
+
+# Mouse Events
+def EVT_LEFT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_DOWN, func)
+
+def EVT_LEFT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_UP, func)
+
+def EVT_MIDDLE_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_MIDDLE_DOWN, func)
+
+def EVT_MIDDLE_UP(win, func):
+    win.Connect(-1, -1, wxEVT_MIDDLE_UP, func)
+
+def EVT_RIGHT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_RIGHT_DOWN, func)
+
+def EVT_RIGHT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_RIGHT_UP, func)
+
+def EVT_MOTION(win, func):
+    win.Connect(-1, -1, wxEVT_MOTION, func)
+
+def EVT_LEFT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_DCLICK, func)
+
+def EVT_MIDDLE_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
+
+def EVT_RIGHT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_RIGHT_DCLICK, func)
+
+def EVT_LEAVE_WINDOW(win, func):
+    win.Connect(-1, -1, wxEVT_LEAVE_WINDOW, func)
+
+def EVT_ENTER_WINDOW(win, func):
+    win.Connect(-1, -1, wxEVT_ENTER_WINDOW, func)
+
+
+# all mouse events
+def EVT_MOUSE_EVENTS(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_DOWN,     func)
+    win.Connect(-1, -1, wxEVT_LEFT_UP,       func)
+    win.Connect(-1, -1, wxEVT_MIDDLE_DOWN,   func)
+    win.Connect(-1, -1, wxEVT_MIDDLE_UP,     func)
+    win.Connect(-1, -1, wxEVT_RIGHT_DOWN,    func)
+    win.Connect(-1, -1, wxEVT_RIGHT_UP,      func)
+    win.Connect(-1, -1, wxEVT_MOTION,        func)
+    win.Connect(-1, -1, wxEVT_LEFT_DCLICK,   func)
+    win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
+    win.Connect(-1, -1, wxEVT_RIGHT_DCLICK,  func)
+    win.Connect(-1, -1, wxEVT_LEAVE_WINDOW,  func)
+    win.Connect(-1, -1, wxEVT_ENTER_WINDOW,  func)
+
+# EVT_COMMAND
+def EVT_COMMAND(win, id, cmd, func):
+    win.Connect(id, -1, cmd, func)
+
+def EVT_COMMAND_RANGE(win, id1, id2, cmd, func):
+    win.Connect(id1, id2, cmd, func)
+
+# Scrolling
+def EVT_SCROLL(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_TOP,       func)
+    win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM,    func)
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEUP,    func)
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN,  func)
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP,    func)
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN,  func)
+    win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK,func)
+
+def EVT_SCROLL_TOP(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_TOP, func)
+
+def EVT_SCROLL_BOTTOM(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM, func)
+
+def EVT_SCROLL_LINEUP(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEUP, func)
+
+def EVT_SCROLL_LINEDOWN(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN, func)
+
+def EVT_SCROLL_PAGEUP(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP, func)
+
+def EVT_SCROLL_PAGEDOWN(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN, func)
+
+def EVT_SCROLL_THUMBTRACK(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK, func)
+
+
+
+# Scrolling, with an id
+def EVT_COMMAND_SCROLL(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_TOP,       func)
+    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
+
+def EVT_COMMAND_SCROLL_TOP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_TOP, func)
+
+def EVT_COMMAND_SCROLL_BOTTOM(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM, func)
+
+def EVT_COMMAND_SCROLL_LINEUP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
+
+def EVT_COMMAND_SCROLL_LINEDOWN(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN, func)
+
+def EVT_COMMAND_SCROLL_PAGEUP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP, func)
+
+def EVT_COMMAND_SCROLL_PAGEDOWN(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN, func)
+
+def EVT_COMMAND_SCROLL_THUMBTRACK(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK, func)
+
+
+# Convenience commands
+def EVT_BUTTON(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_BUTTON_CLICKED, func)
+
+def EVT_CHECKBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_CHECKBOX_CLICKED, func)
+
+def EVT_CHOICE(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_CHOICE_SELECTED, func)
+
+def EVT_LISTBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_SELECTED, func)
+
+def EVT_LISTBOX_DCLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, func)
+
+def EVT_TEXT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TEXT_UPDATED, func)
+
+def EVT_TEXT_ENTER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TEXT_ENTER, func)
+
+def EVT_MENU(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_MENU_SELECTED, func)
+
+def EVT_MENU_RANGE(win, id1, id2, func):
+    win.Connect(id1, id2, wxEVT_COMMAND_MENU_SELECTED, func)
+
+def EVT_SLIDER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_SLIDER_UPDATED, func)
+
+def EVT_RADIOBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RADIOBOX_SELECTED, func)
+
+def EVT_RADIOBUTTON(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RADIOBUTTON_SELECTED, func)
+
+def EVT_VLBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_VLBOX_SELECTED, func)
+
+def EVT_COMBOBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_COMBOBOX_SELECTED, func)
+
+def EVT_TOOL(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TOOL_CLICKED, func)
+
+def EVT_TOOL_RCLICKED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TOOL_RCLICKED, func)
+
+def EVT_TOOL_ENTER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TOOL_ENTER, func)
+
+def EVT_CHECKLISTBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, func)
+
+
+# Generic command events
+
+def EVT_COMMAND_LEFT_CLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LEFT_CLICK, func)
+
+def EVT_COMMAND_LEFT_DCLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LEFT_DCLICK, func)
+
+def EVT_COMMAND_RIGHT_CLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RIGHT_CLICK, func)
+
+def EVT_COMMAND_RIGHT_DCLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RIGHT_DCLICK, func)
+
+def EVT_COMMAND_SET_FOCUS(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_SET_FOCUS, func)
+
+def EVT_COMMAND_KILL_FOCUS(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_KILL_FOCUS, func)
+
+def EVT_COMMAND_ENTER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_ENTER, func)
+
+
+# wxNotebook events
+def EVT_NOTEBOOK_PAGE_CHANGED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, func)
+
+def EVT_NOTEBOOK_PAGE_CHANGING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, func)
+
+
+# wxTreeCtrl events
+def EVT_TREE_BEGIN_DRAG(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_DRAG, func)
+
+def EVT_TREE_BEGIN_RDRAG(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_RDRAG, func)
+
+def EVT_TREE_BEGIN_LABEL_EDIT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, func)
+
+def EVT_TREE_END_LABEL_EDIT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_END_LABEL_EDIT, func)
+
+def EVT_TREE_GET_INFO(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_GET_INFO, func)
+
+def EVT_TREE_SET_INFO(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_SET_INFO, func)
+
+def EVT_TREE_ITEM_EXPANDED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDED, func)
+
+def EVT_TREE_ITEM_EXPANDING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDING, func)
+
+def EVT_TREE_ITEM_COLLAPSED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSED, func)
+
+def EVT_TREE_ITEM_COLLAPSING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSING, func)
+
+def EVT_TREE_SEL_CHANGED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGED, func)
+
+def EVT_TREE_SEL_CHANGING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGING, func)
+
+def EVT_TREE_KEY_DOWN(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_KEY_DOWN, func)
+
+def EVT_TREE_DELETE_ITEM(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_DELETE_ITEM, func)
+
+
+# wxSpinButton
+def EVT_SPIN_UP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
+
+def EVT_SPIN_DOWN(win, id, func):
+    win.Connect(id, -1,wxEVT_SCROLL_LINEDOWN, func)
+
+def EVT_SPIN(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_TOP,       func)
+    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
+
+
+
+
+# wxTaskBarIcon
+def EVT_TASKBAR_MOVE(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_MOVE, func)
+
+def EVT_TASKBAR_LEFT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DOWN, func)
+
+def EVT_TASKBAR_LEFT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_UP, func)
+
+def EVT_TASKBAR_RIGHT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DOWN, func)
+
+def EVT_TASKBAR_RIGHT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_UP, func)
+
+def EVT_TASKBAR_LEFT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DCLICK, func)
+
+def EVT_TASKBAR_RIGHT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DCLICK, func)
+
+
+# wxGrid
+def EVT_GRID_SELECT_CELL(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_SELECT_CELL, fn)
+
+def EVT_GRID_CREATE_CELL(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CREATE_CELL, fn)
+
+def EVT_GRID_CHANGE_LABELS(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CHANGE_LABELS, fn)
+
+def EVT_GRID_CHANGE_SEL_LABEL(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CHANGE_SEL_LABEL, fn)
+
+def EVT_GRID_CELL_CHANGE(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CELL_CHANGE, fn)
+
+def EVT_GRID_CELL_LCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CELL_LCLICK, fn)
+
+def EVT_GRID_CELL_RCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CELL_RCLICK, fn)
+
+def EVT_GRID_LABEL_LCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_LABEL_LCLICK, fn)
+
+def EVT_GRID_LABEL_RCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_LABEL_RCLICK, fn)
+
+
+# wxSashWindow
+def EVT_SASH_DRAGGED(win, id, func):
+    win.Connect(id, -1, wxEVT_SASH_DRAGGED, func)
+
+def EVT_SASH_DRAGGED_RANGE(win, id1, id2, func):
+    win.Connect(id1, id2, wxEVT_SASH_DRAGGED, func)
+
+def EVT_QUERY_LAYOUT_INFO(win, func):
+    win.Connect(-1, -1, wxEVT_EVT_QUERY_LAYOUT_INFO, func)
+
+def EVT_CALCULATE_LAYOUT(win, func):
+    win.Connect(-1, -1, wxEVT_EVT_CALCULATE_LAYOUT, func)
+
+
+# wxListCtrl
+def EVT_LIST_BEGIN_DRAG(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_DRAG, func)
+
+def EVT_LIST_BEGIN_RDRAG(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_RDRAG, func)
+
+def EVT_LIST_BEGIN_LABEL_EDIT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, func)
+
+def EVT_LIST_END_LABEL_EDIT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_END_LABEL_EDIT, func)
+
+def EVT_LIST_DELETE_ITEM(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_DELETE_ITEM, func)
+
+def EVT_LIST_DELETE_ALL_ITEMS(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, func)
+
+def EVT_LIST_GET_INFO(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_GET_INFO, func)
+
+def EVT_LIST_SET_INFO(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_SET_INFO, func)
+
+def EVT_LIST_ITEM_SELECTED(win, id, func):
+    win.Connect(id, -1,  wxEVT_COMMAND_LIST_ITEM_SELECTED, func)
+
+def EVT_LIST_ITEM_DESELECTED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_DESELECTED, func)
+
+def EVT_LIST_KEY_DOWN(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_KEY_DOWN, func)
+
+def EVT_LIST_INSERT_ITEM(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_INSERT_ITEM, func)
+
+def EVT_LIST_COL_CLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LIST_COL_CLICK, func)
+
+
+#----------------------------------------------------------------------
+
+class wxTimer(wxPyTimer):
+    def __init__(self):
+        wxPyTimer.__init__(self, self.Notify)   # derived class must provide
+                                                # Notify(self) method.
+
+#----------------------------------------------------------------------
+# Some wxWin methods can take "NULL" as parameters, but the shadow classes
+# expect an object with the SWIG pointer as a 'this' member.  This class
+# and instance fools the shadow into passing the NULL pointer.
+
+class NullObj:
+    this = 'NULL'       # SWIG converts this to (void*)0
+
+NULL = NullObj()
+
+
+#----------------------------------------------------------------------
+# aliases
+
+wxColor      = wxColour
+wxNamedColor = wxNamedColour
+
+wxPyDefaultPosition.Set(-1,-1)
+wxPyDefaultSize.Set(-1,-1)
+
+# aliases so that C++ documentation applies:
+wxDefaultPosition = wxPyDefaultPosition
+wxDefaultSize     = wxPyDefaultSize
+
+#----------------------------------------------------------------------
+
+## class wxPyStdOutWindow(wxFrame):
+##     def __init__(self, title = "wxPython: stdout/stderr"):
+##         wxFrame.__init__(self, NULL, title)
+##         self.title = title
+##         self.text = wxTextWindow(self)
+##         self.text.SetFont(wxFont(10, wxMODERN, wxNORMAL, wxBOLD))
+##         self.SetSize(-1,-1,400,200)
+##         self.Show(false)
+##         self.isShown = false
+
+##     def write(self, str):  # with this method,
+##         if not self.isShown:
+##             self.Show(true)
+##             self.isShown = true
+##         self.text.WriteText(str)
+
+##     def OnCloseWindow(self, event): # doesn't allow the window to close, just hides it
+##         self.Show(false)
+##         self.isShown = false
+
+
+_defRedirect = (wxPlatform == '__WXMSW__')
+
+#----------------------------------------------------------------------
+# The main application class.  Derive from this and implement an OnInit
+# method that creates a frame and then calls self.SetTopWindow(frame)
+
+class wxApp(wxPyApp):
+    error = 'wxApp.error'
+
+    def __init__(self, redirect=_defRedirect, filename=None):
+        wxPyApp.__init__(self)
+        self.stdioWin = None
+        self.saveStdio = (sys.stdout, sys.stderr)
+        if redirect:
+            self.RedirectStdio(filename)
+
+        # this initializes wxWindows and then calls our OnInit
+        _wxStart(self.OnInit)
+
+
+    def __del__(self):
+        try:
+            self.RestoreStdio()
+        except:
+            pass
+
+    def RedirectStdio(self, filename):
+        if filename:
+            sys.stdout = sys.stderr = open(filename, 'a')
+        else:
+            raise self.error, 'wxPyStdOutWindow not yet implemented.'
+            #self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow()
+
+    def RestoreStdio(self):
+        sys.stdout, sys.stderr = self.saveStdio
+        if self.stdioWin != None:
+            self.stdioWin.Show(false)
+            self.stdioWin.Destroy()
+            self.stdioWin = None
+
+
+#----------------------------------------------------------------------------
+#
+# $Log$
+# Revision 1.10  1999/02/01 00:10:39  RD
+# Added the missing EVT_LIST_ITEM_SELECTED and friends.
+#
+# Revision 1.9  1999/01/30 07:30:09  RD
+#
+# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+#
+# Various cleanup, tweaks, minor additions, etc. to maintain
+# compatibility with the current wxWindows.
+#
+# Revision 1.8  1999/01/29 21:13:42  HH
+# Added aliases for wxDefaultPosition and wxDefaultSize (from wxPy..) in _extras,
+# so that C++ documentation applies.
+#
+# Revision 1.7  1998/11/25 08:45:21  RD
+#
+# Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+# Added events for wxGrid
+# Other various fixes and additions
+#
+# Revision 1.6  1998/11/16 00:00:52  RD
+# Generic treectrl for wxPython/GTK compiles...
+#
+# Revision 1.5  1998/10/20 07:38:02  RD
+# bug fix
+#
+# Revision 1.4  1998/10/20 06:43:54  RD
+# New wxTreeCtrl wrappers (untested)
+# some changes in helpers
+# etc.
+#
+# Revision 1.3  1998/10/02 06:40:33  RD
+#
+# Version 0.4 of wxPython for MSW.
+#
+# Revision 1.2  1998/08/18 19:48:12  RD
+# more wxGTK compatibility things.
+#
+# It builds now but there are serious runtime problems...
+#
+# Revision 1.1  1998/08/09 08:25:49  RD
+# Initial version
+#
+#
+

utils/wxPython/src/cmndlgs.i

@@ -0,0 +1,359 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        cmndlgs.i
+// Purpose:     SWIG definitions for the Common Dialog Classes
+//
+// Author:      Robin Dunn
+//
+// Created:     7/25/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module cmndlgs
+
+%{
+#include "helpers.h"
+#include <wx/colordlg.h>
+#include <wx/dirdlg.h>
+#include <wx/fontdlg.h>
+#include <wx/printdlg.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import gdi.i
+%import windows.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+class wxColourData {
+public:
+    wxColourData();
+    ~wxColourData();
+
+    bool GetChooseFull();
+    wxColour& GetColour();
+    wxColour GetCustomColour(int i);
+    void SetChooseFull(int flag);
+    void SetColour(const wxColour& colour);
+    void SetCustomColour(int i, const wxColour& colour);
+};
+
+
+class wxColourDialog : public wxDialog {
+public:
+    wxColourDialog(wxWindow* parent, wxColourData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxColourData& GetColourData();
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+class wxDirDialog : public wxDialog {
+public:
+    wxDirDialog(wxWindow* parent,
+                char* message = "Choose a directory",
+                char* defaultPath = "",
+                long style = 0,
+                const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxString GetPath();
+    wxString GetMessage();
+    long GetStyle();
+    void SetMessage(const wxString& message);
+    void SetPath(const wxString& path);
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxFileDialog : public wxDialog {
+public:
+    wxFileDialog(wxWindow* parent,
+                 char* message = "Choose a file",
+                 char* defaultDir = "",
+                 char* defaultFile = "",
+                 char* wildcard = "*.*",
+                 long style = 0,
+                 const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxString GetDirectory();
+    wxString GetFilename();
+    int GetFilterIndex();
+    wxString GetMessage();
+    wxString GetPath();
+    long GetStyle();
+    wxString GetWildcard();
+    void SetDirectory(const wxString& directory);
+    void SetFilename(const wxString& setfilename);
+    void SetFilterIndex(int filterIndex);
+    void SetMessage(const wxString& message);
+    void SetPath(const wxString& path);
+    void SetStyle(long style);
+    void SetWildcard(const wxString& wildCard);
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+//TODO: wxMultipleChoiceDialog
+
+//----------------------------------------------------------------------
+
+class wxSingleChoiceDialog : public wxDialog {
+public:
+    %addmethods {
+        // TODO: ignoring clientData for now...
+        //       SWIG is messing up the &/*'s for some reason.
+        wxSingleChoiceDialog(wxWindow* parent,
+                             wxString* message,
+                             wxString* caption,
+                             int LCOUNT, wxString* LIST,
+                             //char** clientData = NULL,
+                             long style = wxOK | wxCANCEL | wxCENTRE,
+                             wxPoint* pos = &wxPyDefaultPosition) {
+            return new wxSingleChoiceDialog(parent, *message, *caption,
+                                            LCOUNT, LIST, NULL, style, *pos);
+        }
+    }
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    int GetSelection();
+    wxString GetStringSelection();
+    void SetSelection(int sel);
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+class wxTextEntryDialog : public wxDialog {
+public:
+    wxTextEntryDialog(wxWindow* parent,
+                      char* message,
+                      char* caption = "Input Text",
+                      char* defaultValue = "",
+                      long style = wxOK | wxCANCEL | wxCENTRE,
+                      const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxString GetValue();
+    void SetValue(const wxString& value);
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxFontData {
+public:
+    wxFontData();
+    ~wxFontData();
+
+    void EnableEffects(bool enable);
+    bool GetAllowSymbols();
+    wxColour& GetColour();
+    wxFont GetChosenFont();
+    bool GetEnableEffects();
+    wxFont GetInitialFont();
+    bool GetShowHelp();
+    void SetAllowSymbols(bool allowSymbols);
+    void SetChosenFont(const wxFont& font);
+    void SetColour(const wxColour& colour);
+    void SetInitialFont(const wxFont& font);
+    void SetRange(int min, int max);
+    void SetShowHelp(bool showHelp);
+};
+
+
+class wxFontDialog : public wxDialog {
+public:
+    wxFontDialog(wxWindow* parent, wxFontData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxFontData& GetFontData();
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+class wxPageSetupData {
+public:
+    wxPageSetupData();
+    ~wxPageSetupData();
+
+    void EnableHelp(bool flag);
+    void EnableMargins(bool flag);
+    void EnableOrientation(bool flag);
+    void EnablePaper(bool flag);
+    void EnablePrinter(bool flag);
+    wxPoint GetPaperSize();
+    wxPoint GetMarginTopLeft();
+    wxPoint GetMarginBottomRight();
+    wxPoint GetMinMarginTopLeft();
+    wxPoint GetMinMarginBottomRight();
+    int GetOrientation();
+    bool GetDefaultMinMargins();
+    bool GetEnableMargins();
+    bool GetEnableOrientation();
+    bool GetEnablePaper();
+    bool GetEnablePrinter();
+    bool GetEnableHelp();
+    bool GetDefaultInfo();
+    void SetPaperSize(const wxPoint& size);
+    void SetMarginTopLeft(const wxPoint& pt);
+    void SetMarginBottomRight(const wxPoint& pt);
+    void SetMinMarginTopLeft(const wxPoint& pt);
+    void SetMinMarginBottomRight(const wxPoint& pt);
+    void SetOrientation(int orientation);
+    void SetDefaultMinMargins(bool flag);
+    void SetDefaultInfo(bool flag);
+};
+
+
+class wxPageSetupDialog : public wxDialog {
+public:
+    wxPageSetupDialog(wxWindow* parent, wxPageSetupData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxPageSetupData& GetPageSetupData();
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxPrintData {
+public:
+    wxPrintData();
+    ~wxPrintData();
+
+    void EnableHelp(bool flag);
+    void EnablePageNumbers(bool flag);
+    void EnablePrintToFile(bool flag);
+    void EnableSelection(bool flag);
+    bool GetAllPages();
+    bool GetCollate();
+    int GetFromPage();
+    int GetMaxPage();
+    int GetMinPage();
+    int GetNoCopies();
+    int GetOrientation();
+    int GetToPage();
+    void SetCollate(bool flag);
+    void SetFromPage(int page);
+    void SetMaxPage(int page);
+    void SetMinPage(int page);
+    void SetOrientation(int orientation);
+    void SetNoCopies(int n);
+    void SetPrintToFile(bool flag);
+    void SetSetupDialog(bool flag);
+    void SetToPage(int page);
+};
+
+
+class wxPrintDialog : public wxDialog {
+public:
+    wxPrintDialog(wxWindow* parent, wxPrintData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxPrintData& GetPrintData();
+    %new wxDC* GetPrintDC();
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxMessageDialog : public wxDialog {
+public:
+    wxMessageDialog(wxWindow* parent,
+                    char* message,
+                    char* caption = "Message box",
+                    long style = wxOK | wxCANCEL | wxCENTRE,
+                    const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.8  1998/12/17 14:07:25  RR
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.7  1998/12/15 20:41:14  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.6  1998/11/25 08:45:22  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.5  1998/11/15 23:03:43  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.4  1998/10/02 06:40:34  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:13  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:25  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//
+

utils/wxPython/src/controls.i

@@ -0,0 +1,543 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        controls.i
+// Purpose:     Control (widget) classes for wxPython
+//
+// Author:      Robin Dunn
+//
+// Created:     6/10/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module controls
+
+%{
+#include "helpers.h"
+#include <wx/slider.h>
+#include <wx/spinbutt.h>
+
+#ifdef __WXMSW__
+#if wxUSE_OWNER_DRAWN
+#include <wx/checklst.h>
+#endif
+#endif
+
+#ifdef __WXGTK__
+#include <wx/checklst.h>
+#endif
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import windows.i
+%import gdi.i
+%import events.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+%{
+wxValidator wxPyDefaultValidator;       // Non-const default because of SWIG
+%}
+
+//----------------------------------------------------------------------
+
+class wxControl : public wxWindow {
+public:
+    void Command(wxCommandEvent& event);
+    wxString GetLabel();
+    void SetLabel(const wxString& label);
+};
+
+//----------------------------------------------------------------------
+
+class wxButton : public wxControl {
+public:
+    wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
+             const wxPoint& pos = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             long style = 0,
+             const wxValidator& validator = wxPyDefaultValidator,
+             char* name = "button");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void SetDefault();
+};
+
+//----------------------------------------------------------------------
+
+class wxBitmapButton : public wxButton {
+public:
+    wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
+                   const wxPoint& pos = wxPyDefaultPosition,
+                   const wxSize& size = wxPyDefaultSize,
+                   long style = wxBU_AUTODRAW,
+                   const wxValidator& validator = wxPyDefaultValidator,
+                   char* name = "button");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    wxBitmap& GetBitmapLabel();
+    wxBitmap& GetBitmapDisabled();
+    wxBitmap& GetBitmapFocus();
+    wxBitmap& GetBitmapSelected();
+    void SetBitmapDisabled(const wxBitmap& bitmap);
+    void SetBitmapFocus(const wxBitmap& bitmap);
+    void SetBitmapSelected(const wxBitmap& bitmap);
+    void SetBitmapLabel(const wxBitmap& bitmap);
+
+};
+
+//----------------------------------------------------------------------
+
+class wxCheckBox : public wxControl {
+public:
+    wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = 0,
+               const wxValidator& val = wxPyDefaultValidator,
+               char* name = "checkBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool GetValue();
+    void SetValue(const bool state);
+};
+
+//----------------------------------------------------------------------
+
+class wxChoice : public wxControl {
+public:
+    wxChoice(wxWindow *parent, wxWindowID id,
+             const wxPoint& pos = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             int LCOUNT=0, wxString* LIST=NULL,
+             long style = 0,
+             const wxValidator& validator = wxPyDefaultValidator,
+             char* name = "choice");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Append(const wxString& item);
+    void Clear();
+    int FindString(const wxString& string);
+    int GetColumns();
+    int GetSelection();
+    wxString GetString(const int n);
+    wxString GetStringSelection();
+    int Number();
+    void SetColumns(const int n = 1);
+    void SetSelection(const int n);
+    void SetStringSelection(const wxString& string);
+};
+
+//----------------------------------------------------------------------
+
+class wxComboBox : public wxControl {
+public:
+    wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               int LCOUNT=0, wxString* LIST=NULL,
+               long style = 0,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "comboBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Append(const wxString& item);
+    // TODO: void Append(const wxString& item, char* clientData);
+    void Clear();
+    void Copy();
+    void Cut();
+    void Delete(int n);
+    // NotMember??:    void Deselect(int n);
+    int FindString(const wxString& string);
+    // TODO: char* GetClientData(const int n);
+    long GetInsertionPoint();
+    long GetLastPosition();
+    int GetSelection();
+    wxString GetString(int n);
+    wxString GetStringSelection();
+    wxString GetValue();
+    int Number();
+    void Paste();
+    void Replace(long from, long to, const wxString& text);
+    void Remove(long from, long to);
+    // TODO:    void SetClientData(const int n, char* data);
+    void SetInsertionPoint(long pos);
+    void SetInsertionPointEnd();
+    void SetSelection(int n, bool select = TRUE);
+    %name(SetMark)void SetSelection(long from, long to);
+    void SetValue(const wxString& text);
+};
+
+//----------------------------------------------------------------------
+
+class wxGauge : public wxControl {
+public:
+    wxGauge(wxWindow* parent, wxWindowID id, int range,
+            const wxPoint& pos = wxPyDefaultPosition,
+            const wxSize& size = wxPyDefaultSize,
+            long style = wxGA_HORIZONTAL,
+            const wxValidator& validator = wxPyDefaultValidator,
+            char* name = "gauge");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    int GetBezelFace();
+    int GetRange();
+    int GetShadowWidth();
+    int GetValue();
+    void SetBezelFace(int width);
+    void SetRange(int range);
+    void SetShadowWidth(int width);
+    void SetValue(int pos);
+};
+
+//----------------------------------------------------------------------
+
+class wxStaticBox : public wxControl {
+public:
+    wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
+                const wxPoint& pos = wxPyDefaultPosition,
+                const wxSize& size = wxPyDefaultSize,
+                long style = 0,
+                char* name = "staticBox");
+};
+
+
+//----------------------------------------------------------------------
+
+class wxStaticText : public wxControl {
+public:
+    wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
+                 const wxPoint& pos = wxPyDefaultPosition,
+                 const wxSize& size = wxPyDefaultSize,
+                 long style = 0,
+                 char* name = "staticText");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    wxString GetLabel();
+    void SetLabel(const wxString& label);
+};
+
+//----------------------------------------------------------------------
+
+class wxListBox : public wxControl {
+public:
+    wxListBox(wxWindow* parent, wxWindowID id,
+              const wxPoint& pos = wxPyDefaultPosition,
+              const wxSize& size = wxPyDefaultSize,
+              int LCOUNT, wxString* LIST = NULL,
+              long style = 0,
+              const wxValidator& validator = wxPyDefaultValidator,
+              char* name = "listBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Append(const wxString& item);
+    // TODO:    void Append(const wxString& item, char* clientData);
+    void Clear();
+    void Delete(int n);
+    void Deselect(int n);
+    int FindString(const wxString& string);
+    // TODO:    char* GetClientData(const int n);
+    int GetSelection();
+    // TODO: int GetSelections(int **selections);
+    wxString GetString(int n);
+    wxString GetStringSelection();
+    int Number();
+    bool Selected(const int n);
+    void Set(int LCOUNT, wxString* LIST);
+    // TODO:    void SetClientData(const int n, char* data);
+    void SetFirstItem(int n);
+    %name(SetFirstItemStr)void SetFirstItem(const wxString& string);
+    void SetSelection(int n, bool select = TRUE);
+    void SetString(int n, const wxString& string);
+    void SetStringSelection(const wxString& string, bool select = TRUE);
+};
+
+
+//----------------------------------------------------------------------
+
+class wxCheckListBox : public wxListBox {
+public:
+    wxCheckListBox(wxWindow *parent, wxWindowID id,
+                   const wxPoint& pos = wxPyDefaultPosition,
+                   const wxSize& size = wxPyDefaultSize,
+                   int LCOUNT = 0,
+                   wxString* LIST = NULL,
+                   long style = 0,
+                   const wxValidator& validator = wxPyDefaultValidator,
+                   char* name = "listBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool  IsChecked(int uiIndex);
+    void  Check(int uiIndex, bool bCheck = TRUE);
+
+    int GetItemHeight();
+};
+
+//----------------------------------------------------------------------
+
+class wxTextCtrl : public wxControl {
+public:
+    wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = 0,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "text");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Clear();
+    void Copy();
+    void Cut();
+    void DiscardEdits();
+    long GetInsertionPoint();
+    long GetLastPosition();
+    int GetLineLength(long lineNo);
+    wxString GetLineText(long lineNo);
+    int GetNumberOfLines();
+    wxString GetValue();
+    bool IsModified();
+    bool LoadFile(const wxString& filename);
+    void Paste();
+    void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
+    void Remove(long from, long to);
+    void Replace(long from, long to, const wxString& value);
+    bool SaveFile(const wxString& filename);
+    void SetEditable(bool editable);
+    void SetInsertionPoint(long pos);
+    void SetInsertionPointEnd();
+    void SetSelection(long from, long to);
+    void SetValue(const wxString& value);
+    void ShowPosition(long pos);
+    void WriteText(const wxString& text);
+    long XYToPosition(long x, long y);
+};
+
+//----------------------------------------------------------------------
+
+class wxScrollBar : public wxControl {
+public:
+    wxScrollBar(wxWindow* parent, wxWindowID id = -1,
+                const wxPoint& pos = wxPyDefaultPosition,
+                const wxSize& size = wxPyDefaultSize,
+                long style = wxSB_HORIZONTAL,
+                const wxValidator& validator = wxPyDefaultValidator,
+                char* name = "scrollBar");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    int GetRange();
+    int GetPageSize();
+    int GetThumbPosition();
+    int GetThumbSize();
+    void SetThumbPosition(int viewStart);
+    void SetScrollbar(int position, int thumbSize,
+                      int range,    int pageSize,
+                      bool refresh = TRUE);
+};
+
+//----------------------------------------------------------------------
+
+class wxSpinButton : public wxControl {
+public:
+    wxSpinButton(wxWindow* parent, wxWindowID id = -1,
+                 const wxPoint& pos = wxPyDefaultPosition,
+                 const wxSize& size = wxPyDefaultSize,
+                 long style = wxSP_HORIZONTAL,
+                 char* name = "spinButton");
+
+    int GetMax();
+    int GetMin();
+    int GetValue();
+    void SetRange(int min, int max);
+    void SetValue(int value);
+};
+
+//----------------------------------------------------------------------
+
+class wxStaticBitmap : public wxControl {
+public:
+    wxStaticBitmap(wxWindow* parent, wxWindowID id,
+                   const wxBitmap& bitmap,
+                   const wxPoint& pos = wxPyDefaultPosition,
+                   const wxSize& size = wxPyDefaultSize,
+                   long style = 0,
+                   char* name = "staticBitmap");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    wxBitmap& GetBitmap();
+    void SetBitmap(const wxBitmap& bitmap);
+};
+
+//----------------------------------------------------------------------
+
+class wxRadioBox : public wxControl {
+public:
+    wxRadioBox(wxWindow* parent, wxWindowID id,
+               const wxString& label,
+               const wxPoint& point = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               int LCOUNT = 0, wxString* LIST = NULL,
+               int majorDimension = 0,
+               long style = wxRA_HORIZONTAL,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "radioBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    %name(EnableBox)void Enable(bool enable);
+    void Enable(int n, bool enable);
+    int FindString(const wxString& string);
+#ifdef __WXMSW__
+    %name(GetBoxLabel)wxString GetLabel();
+#endif
+    wxString GetLabel(int n);
+    int GetSelection();
+    wxString GetString(int n);
+    wxString GetStringSelection();
+    int Number();
+    %name(SetBoxLabel)void SetLabel(const wxString& label);
+    void SetLabel(int n, const wxString& label);
+    void SetSelection(int n);
+    void SetStringSelection(const wxString& string);
+    void Show(bool show);
+    %name(ShowItem)void Show(int item, bool show);
+};
+
+//----------------------------------------------------------------------
+
+class wxRadioButton : public wxControl {
+public:
+    wxRadioButton(wxWindow* parent, wxWindowID id,
+                  const wxString& label,
+                  const wxPoint& pos = wxPyDefaultPosition,
+                  const wxSize& size = wxPyDefaultSize,
+                  long style = 0,
+                  const wxValidator& validator = wxPyDefaultValidator,
+                  char* name = "radioButton");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool GetValue();
+    void SetValue(bool value);
+};
+
+//----------------------------------------------------------------------
+
+class wxSlider : public wxControl {
+public:
+    wxSlider(wxWindow* parent, wxWindowID id,
+             int value, int minValue, int maxValue,
+             const wxPoint& point = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             long style = wxSL_HORIZONTAL,
+             const wxValidator& validator = wxPyDefaultValidator,
+             char* name = "slider");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void ClearSel();
+    void ClearTicks();
+    int GetLineSize();
+    int GetMax();
+    int GetMin();
+    int GetPageSize();
+    int GetSelEnd();
+    int GetSelStart();
+    int GetThumbLength();
+    int GetTickFreq();
+    int GetValue();
+    void SetRange(int minValue, int maxValue);
+    void SetTickFreq(int n, int pos);
+    void SetLineSize(int lineSize);
+    void SetPageSize(int pageSize);
+    void SetSelection(int startPos, int endPos);
+    void SetThumbLength(int len);
+    void SetTick(int tickPos);
+    void SetValue(int value);
+};
+
+
+//----------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.10  1998/12/17 17:52:19  RD
+// wxPython 0.5.2
+// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
+// versions are much closer now!
+//
+// Revision 1.9  1998/12/17 14:07:29  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.8  1998/12/15 20:41:15  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.7  1998/11/16 00:00:53  RD
+// Generic treectrl for wxPython/GTK compiles...
+//
+// Revision 1.6  1998/11/15 23:03:43  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.5  1998/10/07 07:34:32  RD
+// Version 0.4.1 for wxGTK
+//
+// Revision 1.4  1998/10/02 06:40:35  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:14  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:28  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//
+

utils/wxPython/src/controls2.i

@@ -0,0 +1,451 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        controls2.i
+// Purpose:     More control (widget) classes for wxPython
+//
+// Author:      Robin Dunn
+//
+// Created:     6/10/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module controls2
+
+%{
+#include "helpers.h"
+#include <wx/listctrl.h>
+#include <wx/treectrl.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import windows.i
+%import gdi.i
+%import events.i
+%import controls.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+%{
+extern wxValidator wxPyDefaultValidator;
+%}
+
+//----------------------------------------------------------------------
+
+class wxListItem {
+public:
+    long            m_mask;     // Indicates what fields are valid
+    long            m_itemId;   // The zero-based item position
+    int             m_col;      // Zero-based column, if in report mode
+    long            m_state;    // The state of the item
+    long            m_stateMask; // Which flags of m_state are valid (uses same flags)
+    wxString        m_text;     // The label/header text
+    int             m_image;    // The zero-based index into an image list
+    long            m_data;     // App-defined data
+//    wxColour       *m_colour;   // only wxGLC, not supported by Windows ;->
+
+    // For columns only
+    int             m_format;   // left, right, centre
+    int             m_width;    // width of column
+
+    wxListItem();
+    ~wxListItem();
+};
+
+class wxListEvent: public wxCommandEvent {
+public:
+    int           m_code;
+    long          m_itemIndex;
+    long          m_oldItemIndex;
+    int           m_col;
+    bool          m_cancelled;
+    wxPoint       m_pointDrag;
+    wxListItem    m_item;
+};
+
+
+
+
+class wxListCtrl : public wxControl {
+public:
+    wxListCtrl(wxWindow* parent, wxWindowID id,
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = wxLC_ICON,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "listCtrl");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
+    bool DeleteItem(long item);
+    bool DeleteAllItems();
+    bool DeleteColumn(int col);
+    bool DeleteAllColumns(void);
+    void ClearAll(void);
+#ifdef __WXMSW__
+    wxTextCtrl* EditLabel(long item);
+    bool EndEditLabel(bool cancel);
+    wxTextCtrl* GetEditControl();
+#endif
+    bool EnsureVisible(long item);
+    long FindItem(long start, const wxString& str, bool partial = FALSE);
+    %name(FindItemData)long FindItem(long start, long data);
+    %name(FindItemAtPos)long FindItem(long start, const wxPoint& pt,
+                                      int direction);
+    bool GetColumn(int col, wxListItem& item);
+    int GetColumnWidth(int col);
+    int GetCountPerPage();
+    wxImageList* GetImageList(int which);
+    long GetItemData(long item);
+
+    %addmethods {
+        %new wxListItem* GetItem() {
+            wxListItem* info = new wxListItem;
+            self->GetItem(*info);
+            return info;
+        }
+        %new wxPoint* GetItemPosition(long item) {
+            wxPoint* pos = new wxPoint;
+            self->GetItemPosition(item, *pos);
+            return pos;
+        }
+        %new wxRect* GetItemRect(long item, int code = wxLIST_RECT_BOUNDS) {
+            wxRect* rect= new wxRect;
+            self->GetItemRect(item, *rect, code);
+            return rect;
+        }
+    }
+
+    int GetItemState(long item, long stateMask);
+    int GetItemCount();
+    int GetItemSpacing(bool isSmall);
+    wxString GetItemText(long item);
+    long GetNextItem(long item,
+                     int geometry = wxLIST_NEXT_ALL,
+                     int state = wxLIST_STATE_DONTCARE);
+    int GetSelectedItemCount();
+#ifdef __WXMSW__
+    wxColour GetTextColour();
+    void SetTextColour(const wxColour& col);
+#endif
+    long GetTopItem();
+    long HitTest(const wxPoint& point, int& OUTPUT);
+    %name(InsertColumnWithInfo)long InsertColumn(long col, wxListItem& info);
+    long InsertColumn(long col, const wxString& heading,
+                      int format = wxLIST_FORMAT_LEFT,
+                      int width = -1);
+
+    long InsertItem(wxListItem& info);
+    %name(InsertStringItem)     long InsertItem(long index, const wxString& label);
+    %name(InsertImageItem)      long InsertItem(long index, int imageIndex);
+    %name(InsertImageStringItem)long InsertItem(long index, const wxString& label,
+                                                int imageIndex);
+
+    bool ScrollList(int dx, int dy);
+    void SetBackgroundColour(const wxColour& col);
+    bool SetColumn(int col, wxListItem& item);
+    bool SetColumnWidth(int col, int width);
+    void SetImageList(wxImageList* imageList, int which);
+    bool SetItem(wxListItem& info);
+    %name(SetItemString)long SetItem(long index, int col, const wxString& label,
+                                     int imageId = -1);
+    bool SetItemData(long item, long data);
+    bool SetItemImage(long item, int image, int selImage);
+    bool SetItemPosition(long item, const wxPoint& pos);
+    bool SetItemState(long item, long state, long stateMask);
+    void SetItemText(long item, const wxString& text);
+    void SetSingleStyle(long style, bool add = TRUE);
+    void SetWindowStyleFlag(long style);
+    // TODO:  bool SortItems(wxListCtrlCompare fn, long data);
+};
+
+
+
+//----------------------------------------------------------------------
+
+
+class wxTreeItemId {
+public:
+    wxTreeItemId();
+    ~wxTreeItemId();
+    bool IsOk() const { return m_itemId != 0; }
+
+//    %addmethods {
+//        long GetId() { return (long)(*self); }
+//    }
+};
+
+
+
+// ****  This isn't very useful yet.  This needs to be specialized to enable
+// derived Python classes...
+class wxTreeItemData {
+public:
+    wxTreeItemData();
+    ~wxTreeItemData();
+
+    const wxTreeItemId& GetId();
+    void SetId(const wxTreeItemId& id);
+};
+
+
+
+
+class wxTreeEvent : public wxCommandEvent {
+public:
+    wxTreeItemId GetItem();
+    wxTreeItemId GetOldItem();
+    wxPoint GetPoint();
+    int GetCode();
+    void Veto();
+};
+
+
+// These are for the GetFirstChild/GetNextChild methods below
+%typemap(python, in)     long& INOUT = long* INOUT;
+%typemap(python, argout) long& INOUT = long* INOUT;
+
+
+class wxTreeCtrl : public wxControl {
+public:
+    wxTreeCtrl(wxWindow *parent, wxWindowID id = -1,
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "wxTreeCtrl");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    size_t GetCount();
+    unsigned int GetIndent();
+    void SetIndent(unsigned int indent);
+    wxImageList *GetImageList();
+    wxImageList *GetStateImageList();
+    void SetImageList(wxImageList *imageList);
+    void SetStateImageList(wxImageList *imageList);
+
+    wxString GetItemText(const wxTreeItemId& item);
+    int GetItemImage(const wxTreeItemId& item);
+    int GetItemSelectedImage(const wxTreeItemId& item);
+    wxTreeItemData *GetItemData(const wxTreeItemId& item);
+
+    void SetItemText(const wxTreeItemId& item, const wxString& text);
+    void SetItemImage(const wxTreeItemId& item, int image);
+    void SetItemSelectedImage(const wxTreeItemId& item, int image);
+    void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
+    void SetItemHasChildren(const wxTreeItemId& item, bool hasChildren = TRUE);
+
+    bool IsVisible(const wxTreeItemId& item);
+    bool ItemHasChildren(const wxTreeItemId& item);
+    bool IsExpanded(const wxTreeItemId& item);
+    bool IsSelected(const wxTreeItemId& item);
+
+    wxTreeItemId GetRootItem();
+    wxTreeItemId GetSelection();
+    wxTreeItemId GetParent(const wxTreeItemId& item);
+
+    wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& INOUT);
+    wxTreeItemId GetNextChild(const wxTreeItemId& item, long& INOUT);
+    wxTreeItemId GetNextSibling(const wxTreeItemId& item);
+    wxTreeItemId GetPrevSibling(const wxTreeItemId& item);
+    wxTreeItemId GetFirstVisibleItem();
+    wxTreeItemId GetNextVisible(const wxTreeItemId& item);
+    wxTreeItemId GetPrevVisible(const wxTreeItemId& item);
+
+
+    wxTreeItemId AddRoot(const wxString& text,
+                         int image = -1, int selectedImage = -1,
+                         wxTreeItemData *data = NULL);
+    wxTreeItemId PrependItem(const wxTreeItemId& parent,
+                             const wxString& text,
+                             int image = -1, int selectedImage = -1,
+                             wxTreeItemData *data = NULL);
+    wxTreeItemId InsertItem(const wxTreeItemId& parent,
+                            const wxTreeItemId& idPrevious,
+                            const wxString& text,
+                            int image = -1, int selectedImage = -1,
+                            wxTreeItemData *data = NULL);
+    wxTreeItemId AppendItem(const wxTreeItemId& parent,
+                            const wxString& text,
+                            int image = -1, int selectedImage = -1,
+                            wxTreeItemData *data = NULL);
+
+    void Delete(const wxTreeItemId& item);
+    void DeleteChildren(const wxTreeItemId& item);
+    void DeleteAllItems();
+
+    void Expand(const wxTreeItemId& item);
+    void Collapse(const wxTreeItemId& item);
+    void CollapseAndReset(const wxTreeItemId& item);
+    void Toggle(const wxTreeItemId& item);
+
+    void Unselect();
+    void SelectItem(const wxTreeItemId& item);
+    void EnsureVisible(const wxTreeItemId& item);
+    void ScrollTo(const wxTreeItemId& item);
+
+    wxTextCtrl* EditLabel(const wxTreeItemId& item);
+                          // **** figure out how to do this
+                          // wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+    wxTextCtrl* GetEditControl();
+    void EndEditLabel(const wxTreeItemId& item, bool discardChanges = FALSE);
+
+//    void SortChildren(const wxTreeItemId& item);
+                      // **** And this too
+                      // wxTreeItemCmpFunc *cmpFunction = NULL);
+
+    void SetItemBold(const wxTreeItemId& item, bool bold = TRUE);
+    bool IsBold(const wxTreeItemId& item) const;
+    wxTreeItemId HitTest(const wxPoint& point);
+};
+
+
+//----------------------------------------------------------------------
+
+#ifdef SKIPTHIS
+#ifdef __WXMSW__
+class wxTabEvent : public wxCommandEvent {
+public:
+};
+
+
+
+class wxTabCtrl : public wxControl {
+public:
+    wxTabCtrl(wxWindow* parent, wxWindowID id,
+              const wxPoint& pos = wxPyDefaultPosition,
+              const wxSize& size = wxPyDefaultSize,
+              long style = 0,
+              char* name = "tabCtrl");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool DeleteAllItems();
+    bool DeleteItem(int item);
+    wxImageList* GetImageList();
+    int GetItemCount();
+    // TODO: void* GetItemData();
+    int GetItemImage(int item);
+
+    %addmethods {
+        %new wxRect* GetItemRect(int item) {
+            wxRect* rect = new wxRect;
+            self->GetItemRect(item, *rect);
+            return rect;
+        }
+    }
+
+    wxString GetItemText(int item);
+    bool GetRowCount();
+    int GetSelection();
+    int HitTest(const wxPoint& pt, long& OUTPUT);
+    void InsertItem(int item, const wxString& text,
+                    int imageId = -1, void* clientData = NULL);
+    // TODO: bool SetItemData(int item, void* data);
+    bool SetItemImage(int item, int image);
+    void SetImageList(wxImageList* imageList);
+    void SetItemSize(const wxSize& size);
+    bool SetItemText(int item, const wxString& text);
+    void SetPadding(const wxSize& padding);
+    int SetSelection(int item);
+
+};
+
+#endif
+#endif
+
+//----------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.14  1999/01/30 07:30:10  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.13  1998/12/17 14:07:34  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.12  1998/12/16 22:10:52  RD
+//
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.11  1998/12/15 20:41:16  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.10  1998/11/25 08:45:23  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.9  1998/11/16 00:00:54  RD
+// Generic treectrl for wxPython/GTK compiles...
+//
+// Revision 1.8  1998/11/11 04:40:20  RD
+// wxTreeCtrl now works (sort of) for wxPython-GTK.  This is the new
+// TreeCtrl in src/gtk/treectrl.cpp not the old generic one.
+//
+// Revision 1.7  1998/11/11 03:12:25  RD
+//
+// Additions for wxTreeCtrl
+//
+// Revision 1.6  1998/10/20 06:43:55  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.5  1998/10/07 07:34:33  RD
+// Version 0.4.1 for wxGTK
+//
+// Revision 1.4  1998/10/02 06:40:36  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:15  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:30  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//

utils/wxPython/src/events.i

@@ -0,0 +1,341 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        events.i
+// Purpose:     SWIGgable Event classes for wxPython
+//
+// Author:      Robin Dunn
+//
+// Created:     5/24/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module events
+
+%{
+#include "helpers.h"
+#include <wx/spinbutt.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+
+//---------------------------------------------------------------------------
+
+class wxEvent {
+public:
+    wxObject* GetEventObject();
+    wxEventType GetEventType();
+    int GetId();
+    bool GetSkipped();
+    long GetTimestamp();
+    void SetEventObject(wxObject* object);
+    void SetEventType(wxEventType typ);
+    void SetId(int id);
+    void SetTimestamp(long timeStamp);
+    void Skip(bool skip = TRUE);
+};
+
+//---------------------------------------------------------------------------
+
+class wxSizeEvent : public wxEvent {
+public:
+    wxSize GetSize();
+};
+
+//---------------------------------------------------------------------------
+
+class wxCloseEvent : public wxEvent {
+public:
+    bool CanVeto();
+// ****    bool GetSessionEnding();
+    bool GetLoggingOff();
+    void Veto(bool veto = TRUE);
+    bool GetVeto();
+    void SetForce(bool force);
+    void SetCanVeto(bool canVeto);
+    void SetLoggingOff(bool loggingOff);
+    bool GetForce();
+};
+
+//---------------------------------------------------------------------------
+
+class wxCommandEvent : public wxEvent {
+public:
+    bool Checked();
+    long GetExtraLong();
+    int GetInt();
+    int GetSelection();
+    char* GetString();
+    bool IsSelection();
+
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxScrollEvent: public wxCommandEvent {
+public:
+    int GetOrientation();
+    int GetPosition();
+};
+
+//---------------------------------------------------------------------------
+
+class wxSpinEvent : public wxScrollEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxMouseEvent: public wxEvent {
+public:
+    bool IsButton();
+    bool ButtonDown(int but = -1);
+    bool ButtonDClick(int but = -1);
+    bool ButtonUp(int but = -1);
+    bool Button(int but);
+    bool ButtonIsDown(int but);
+    bool ControlDown();
+    bool MetaDown();
+    bool AltDown();
+    bool ShiftDown();
+    bool LeftDown();
+    bool MiddleDown();
+    bool RightDown();
+    bool LeftUp();
+    bool MiddleUp();
+    bool RightUp();
+    bool LeftDClick();
+    bool MiddleDClick();
+    bool RightDClick();
+    bool LeftIsDown();
+    bool MiddleIsDown();
+    bool RightIsDown();
+    bool Dragging();
+    bool Moving();
+    bool Entering();
+    bool Leaving();
+    void Position(long *OUTPUT, long *OUTPUT);
+    wxPoint GetPosition();
+    wxPoint GetLogicalPosition(const wxDC& dc);
+    long GetX();
+    long GetY();
+};
+
+//---------------------------------------------------------------------------
+
+class wxKeyEvent: public wxEvent {
+public:
+    bool ControlDown();
+    bool MetaDown();
+    bool AltDown();
+    bool ShiftDown();
+    long KeyCode();
+    void Position(float *OUTPUT, float *OUTPUT);
+    float GetX();
+    float GetY();
+};
+
+//---------------------------------------------------------------------------
+
+class wxMoveEvent: public wxEvent {
+public:
+    wxPoint GetPosition();
+};
+
+//---------------------------------------------------------------------------
+
+class wxPaintEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxEraseEvent: public wxEvent {
+public:
+    wxDC *GetDC();
+};
+
+//---------------------------------------------------------------------------
+
+class wxFocusEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxActivateEvent: public wxEvent{
+public:
+    bool GetActive();
+};
+
+//---------------------------------------------------------------------------
+
+class wxInitDialogEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxMenuEvent: public wxEvent {
+public:
+    int GetMenuId();
+};
+
+//---------------------------------------------------------------------------
+
+class wxShowEvent: public wxEvent {
+public:
+    void SetShow(bool show);
+    bool GetShow();
+};
+
+//---------------------------------------------------------------------------
+
+class wxIconizeEvent: public wxEvent {
+public:
+};
+
+//---------------------------------------------------------------------------
+
+class wxMaximizeEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxJoystickEvent: public wxEvent {
+public:
+    wxPoint GetPosition();
+    int GetZPosition();
+    int GetButtonState();
+    int GetButtonChange();
+    int GetJoystick();
+    void SetJoystick(int stick);
+    void SetButtonState(int state);
+    void SetButtonChange(int change);
+    void SetPosition(const wxPoint& pos);
+    void SetZPosition(int zPos);
+    bool IsButton();
+    bool IsMove();
+    bool IsZMove();
+    bool ButtonDown(int but = wxJOY_BUTTON_ANY);
+    bool ButtonUp(int but = wxJOY_BUTTON_ANY);
+    bool ButtonIsDown(int but =  wxJOY_BUTTON_ANY);
+};
+
+//---------------------------------------------------------------------------
+
+class wxDropFilesEvent: public wxEvent {
+public:
+    wxPoint GetPosition();
+    int GetNumberOfFiles();
+
+    %addmethods {
+        PyObject* GetFiles() {
+            int         count = self->GetNumberOfFiles();
+            wxString*   files = self->GetFiles();
+            PyObject*   list  = PyList_New(count);
+
+            if (!list) {
+                PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
+                return NULL;
+            }
+
+            for (int i=0; i<count; i++) {
+                PyList_SetItem(list, i, PyString_FromString((const char*)files[i]));
+            }
+            return list;
+        }
+    }
+};
+
+//---------------------------------------------------------------------------
+
+class wxIdleEvent: public wxEvent {
+public:
+    void RequestMore(bool needMore = TRUE);
+    bool MoreRequested();
+};
+
+//---------------------------------------------------------------------------
+
+class wxUpdateUIEvent: public wxEvent {
+public:
+    bool GetChecked();
+    bool GetEnabled();
+    wxString GetText();
+    bool GetSetText();
+    bool GetSetChecked();
+    bool GetSetEnabled();
+
+    void Check(bool check);
+    void Enable(bool enable);
+    void SetText(const wxString& text);
+};
+
+//---------------------------------------------------------------------------
+
+class wxSysColourChangedEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.5  1998/12/15 20:41:17  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.4  1998/11/16 00:00:55  RD
+// Generic treectrl for wxPython/GTK compiles...
+//
+// Revision 1.3  1998/10/20 06:43:56  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.2  1998/08/15 07:36:33  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:50  RD
+// Initial version
+//
+//
+

utils/wxPython/src/frames.i

@@ -0,0 +1,122 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        frames.i
+// Purpose:     SWIG definitions of various window classes
+//
+// Author:      Robin Dunn
+//
+// Created:     8/27/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module frames
+
+%{
+#include "helpers.h"
+#include <wx/minifram.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import gdi.i
+%import windows.i
+%import stattool.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+class wxFrame : public wxWindow {
+public:
+    wxFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
+            const wxPoint& pos = wxPyDefaultPosition,
+            const wxSize& size = wxPyDefaultSize,
+            long style = wxDEFAULT_FRAME_STYLE,
+            char* name = "frame");
+
+    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
+
+    void Centre(int direction = wxBOTH);
+#ifdef __WXMSW__
+    void Command(int id);
+#endif
+    wxStatusBar* CreateStatusBar(int number = 1,
+                                 long style = wxST_SIZEGRIP,
+                                 wxWindowID id = -1,
+                                 char* name = "statusBar");
+    wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL|wxTB_FLAT,
+                             wxWindowID id = -1,
+                             char* name = "toolBar");
+
+    wxMenuBar* GetMenuBar();
+    wxStatusBar* GetStatusBar();
+    wxString GetTitle();
+    wxToolBar* GetToolBar();
+    void Iconize(bool iconize);
+    bool IsIconized();
+    void Maximize(bool maximize);
+    void SetAcceleratorTable(const wxAcceleratorTable& accel);
+    void SetIcon(const wxIcon& icon);
+    void SetMenuBar(wxMenuBar* menuBar);
+    void SetStatusBar(wxStatusBar *statusBar);
+    void SetStatusText(const wxString& text, int number = 0);
+    void SetStatusWidths(int LCOUNT, int* LIST); // uses typemap
+    void SetTitle(const wxString& title);
+    void SetToolBar(wxToolBar* toolbar);
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxMiniFrame : public wxFrame {
+public:
+    wxMiniFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
+                const wxPoint& pos = wxPyDefaultPosition,
+                const wxSize& size = wxPyDefaultSize,
+                long style = wxDEFAULT_FRAME_STYLE,
+                char* name = "frame");
+
+    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
+};
+
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.4  1998/12/16 22:10:53  RD
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.3  1998/12/15 20:41:18  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+
+
+
+
+
+

utils/wxPython/src/gdi.i

@@ -0,0 +1,582 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        gdi.i
+// Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
+//
+// Author:      Robin Dunn
+//
+// Created:     7/7/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module gdi
+
+%{
+#include "helpers.h"
+#include <wx/metafile.h>
+#ifndef __WXMSW__
+#include <wx/dcps.h>
+#endif
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+
+//---------------------------------------------------------------------------
+
+class wxBitmap {
+public:
+    wxBitmap(const wxString& name, long type);
+    ~wxBitmap();
+
+#ifdef __WXMSW__
+    void Create(int width, int height, int depth = -1);
+#endif
+    int GetDepth();
+    int GetHeight();
+    wxPalette* GetPalette();
+    wxMask* GetMask();
+    int GetWidth();
+    bool LoadFile(const wxString& name, long flags);
+    bool Ok();
+    bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
+    void SetDepth(int depth);
+    void SetHeight(int height);
+    void SetMask(wxMask* mask);
+#ifdef __WXMSW__
+    void SetPalette(wxPalette& palette);
+#endif
+    void SetWidth(int width);
+};
+
+%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
+wxBitmap* wxNoRefBitmap(char* name, long flags);
+
+%{                              // Alternate 'constructor'
+    wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
+        return new wxBitmap(width, height, depth);
+    }
+
+                                // This one won't own the reference, so Python won't call
+                                // the dtor, this is good for toolbars and such where
+                                // the parent will manage the bitmap.
+    wxBitmap* wxNoRefBitmap(char* name, long flags) {
+        return new wxBitmap(name, flags);
+    }
+%}
+
+//---------------------------------------------------------------------------
+
+class wxMask {
+public:
+    wxMask(const wxBitmap& bitmap);
+    ~wxMask();
+};
+
+%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
+%{
+    wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
+        return new wxMask(bitmap, colour);
+    }
+%}
+
+
+//---------------------------------------------------------------------------
+
+
+class wxIcon : public wxBitmap {
+public:
+#ifdef __WXMSW__
+    wxIcon(const wxString& name, long flags,
+           int desiredWidth = -1, int desiredHeight = -1);
+#endif
+    ~wxIcon();
+
+    int GetDepth();
+    int GetHeight();
+    int GetWidth();
+    bool LoadFile(const wxString& name, long flags);
+    bool Ok();
+    void SetDepth(int depth);
+    void SetHeight(int height);
+    void SetWidth(int width);
+};
+
+//---------------------------------------------------------------------------
+
+class wxCursor : public wxBitmap {
+public:
+#ifdef __WXMSW__
+    wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
+#endif
+    ~wxCursor();
+    bool Ok();
+};
+
+%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
+%{                              // Alternate 'constructor'
+    wxCursor* wxPyStockCursor(int id) {
+        return new wxCursor(id);
+    }
+%}
+
+//----------------------------------------------------------------------
+
+class wxFont {
+public:
+    // I'll do it this way to use long-lived objects and not have to
+    // worry about when python may delete the object.
+    %addmethods {
+        wxFont( int pointSize, int family, int style, int weight,
+                int underline=FALSE, char* faceName = "") {
+
+            return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
+                                                   underline, faceName);
+        }
+        // NO Destructor.
+    }
+
+
+    wxString GetFaceName();
+    int GetFamily();
+#ifdef __WXMSW__
+    int GetFontId();
+#endif
+    int GetPointSize();
+    int GetStyle();
+    bool GetUnderlined();
+    int GetWeight();
+    void SetFaceName(const wxString& faceName);
+    void SetFamily(int family);
+    void SetPointSize(int pointSize);
+    void SetStyle(int style);
+    void SetUnderlined(bool underlined);
+    void SetWeight(int weight);
+};
+
+//----------------------------------------------------------------------
+
+class wxColour {
+public:
+    wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
+    ~wxColour();
+    unsigned char Red();
+    unsigned char Green();
+    unsigned char Blue();
+    bool Ok();
+    void Set(unsigned char red, unsigned char green, unsigned char blue);
+    %addmethods {
+        PyObject* Get() {
+            PyObject* rv = PyTuple_New(3);
+            PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
+            PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
+            PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
+            return rv;
+        }
+    }
+};
+
+%new wxColour* wxNamedColour(const wxString& colorName);
+%{                                      // Alternate 'constructor'
+    wxColour* wxNamedColour(const wxString& colorName) {
+        return new wxColour(colorName);
+    }
+%}
+
+
+//----------------------------------------------------------------------
+
+typedef unsigned long wxDash;
+
+class wxPen {
+public:
+    // I'll do it this way to use long-lived objects and not have to
+    // worry about when python may delete the object.
+    %addmethods {
+        wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
+            return wxThePenList->FindOrCreatePen(*colour, width, style);
+        }
+        // NO Destructor.
+    }
+
+    int GetCap();
+    wxColour& GetColour();
+
+    int GetJoin();
+    int GetStyle();
+    int GetWidth();
+    bool Ok();
+    void SetCap(int cap_style);
+    void SetColour(wxColour& colour);
+    void SetJoin(int join_style);
+    void SetStyle(int style);
+    void SetWidth(int width);
+
+#ifdef __WXMSW__
+            // **** This one needs to return a list of ints (wxDash)
+    int GetDashes(wxDash **dashes);
+    wxBitmap* GetStipple();
+    void SetDashes(int LCOUNT, wxDash* LIST);
+    void SetStipple(wxBitmap& stipple);
+#endif
+};
+
+//----------------------------------------------------------------------
+
+class wxBrush {
+public:
+    // I'll do it this way to use long-lived objects and not have to
+    // worry about when python may delete the object.
+    %addmethods {
+        wxBrush(wxColour* colour, int style=wxSOLID) {
+            return wxTheBrushList->FindOrCreateBrush(*colour, style);
+        }
+        // NO Destructor.
+    }
+
+    wxColour& GetColour();
+    wxBitmap * GetStipple();
+    int GetStyle();
+    bool Ok();
+    void SetColour(wxColour &colour);
+    void SetStipple(wxBitmap& bitmap);
+    void SetStyle(int style);
+};
+
+//----------------------------------------------------------------------
+
+
+
+class wxDC {
+public:
+//    wxDC(); **** abstract base class, can't instantiate.
+    ~wxDC();
+
+    void BeginDrawing();
+    bool Blit(long xdest, long ydest, long width, long height,
+                wxDC *source, long xsrc, long ysrc, long logical_func);
+    void Clear();
+    void CrossHair(long x, long y);
+    void DestroyClippingRegion();
+    long DeviceToLogicalX(long x);
+    long DeviceToLogicalXRel(long x);
+    long DeviceToLogicalY(long y);
+    long DeviceToLogicalYRel(long y);
+    void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
+    void DrawEllipse(long x, long y, long width, long height);
+    void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
+    void DrawIcon(const wxIcon& icon, long x, long y);
+    void DrawLine(long x1, long y1, long x2, long y2);
+    void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
+    void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
+                     int fill_style=wxODDEVEN_RULE);
+    void DrawPoint(long x, long y);
+    void DrawRectangle(long x, long y, long width, long height);
+    void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
+    void DrawSpline(int LCOUNT, wxPoint* LIST);
+    void DrawText(const wxString& text, long x, long y);
+    void EndDoc();
+    void EndDrawing();
+    void EndPage();
+    void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
+    wxBrush&  GetBackground();
+    wxBrush&  GetBrush();
+    long GetCharHeight();
+    long GetCharWidth();
+    void GetClippingBox(long *OUTPUT, long *OUTPUT,
+                        long *OUTPUT, long *OUTPUT);
+    wxFont& GetFont();
+    int GetLogicalFunction();
+    int GetMapMode();
+    bool GetOptimization();
+    wxPen& GetPen();
+    %addmethods {
+        %new wxColour* GetPixel(long x, long y) {
+            wxColour* wc = new wxColour();
+            self->GetPixel(x, y, wc);
+            return wc;
+        }
+    }
+    void GetSize(int* OUTPUT, int* OUTPUT); //void GetSize(long* OUTPUT, long* OUTPUT);
+    wxColour& GetTextBackground();
+    void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT,
+                       long *OUTPUT, long *OUTPUT);
+    wxColour& GetTextForeground();
+    long LogicalToDeviceX(long x);
+    long LogicalToDeviceXRel(long x);
+    long LogicalToDeviceY(long y);
+    long LogicalToDeviceYRel(long y);
+    long MaxX();
+    long MaxY();
+    long MinX();
+    long MinY();
+    bool Ok();
+    void SetDeviceOrigin(long x, long y);
+    void SetBackground(const wxBrush& brush);
+    void SetBackgroundMode(int mode);
+    void SetClippingRegion(long x, long y, long width, long height);
+    void SetPalette(const wxPalette& colourMap);
+    void SetBrush(const wxBrush& brush);
+    void SetFont(const wxFont& font);
+    void SetLogicalFunction(int function);
+    void SetMapMode(int mode);
+    void SetOptimization(bool optimize);
+    void SetPen(const wxPen& pen);
+    void SetTextBackground(const wxColour& colour);
+    void SetTextForeground(const wxColour& colour);
+    void SetUserScale(double x_scale, double y_scale);
+    bool StartDoc(const wxString& message);
+    void StartPage();
+
+
+    %addmethods {
+            // This one is my own creation...
+        void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
+            wxMemoryDC* memDC = new wxMemoryDC;
+            memDC->SelectObject(bitmap);
+            if (swapPalette)
+                self->SetPalette(*bitmap.GetPalette());
+            self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
+                    0, 0, self->GetLogicalFunction());
+            memDC->SelectObject(wxNullBitmap);
+            delete memDC;
+        }
+    }
+};
+
+
+//----------------------------------------------------------------------
+
+class wxMemoryDC : public wxDC {
+public:
+    wxMemoryDC();
+
+    void SelectObject(const wxBitmap& bitmap);
+}
+
+%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
+%{                                      // Alternate 'constructor'
+    wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
+        return new wxMemoryDC(oldDC);
+    }
+%}
+
+
+//---------------------------------------------------------------------------
+
+class wxScreenDC : public wxDC {
+public:
+    wxScreenDC();
+
+    bool StartDrawingOnTop(wxWindow* window);
+    %name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
+    bool EndDrawingOnTop();
+};
+
+//---------------------------------------------------------------------------
+
+class wxClientDC : public wxDC {
+public:
+      wxClientDC(wxWindow* win);
+};
+
+//---------------------------------------------------------------------------
+
+class wxPaintDC : public wxDC {
+public:
+      wxPaintDC(wxWindow* win);
+};
+
+//---------------------------------------------------------------------------
+
+class wxWindowDC : public wxDC {
+public:
+      wxWindowDC(wxWindow* win);
+};
+
+//---------------------------------------------------------------------------
+
+#ifndef __WXMSW__
+class wxPostScriptDC : public wxDC {
+public:
+      wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
+};
+#endif
+
+//---------------------------------------------------------------------------
+
+#ifdef __WXMSW__
+class  wxPrinterDC : public wxDC {
+public:
+    wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
+                bool interactive = TRUE, int orientation = wxPORTRAIT);
+};
+#endif
+
+//---------------------------------------------------------------------------
+
+#ifdef __WXMSW__
+class wxMetaFileDC : public wxDC {
+public:
+    wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
+    wxMetaFile* Close();
+};
+#endif
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+
+
+%readonly
+extern wxFont *wxNORMAL_FONT;
+extern wxFont *wxSMALL_FONT;
+extern wxFont *wxITALIC_FONT;
+extern wxFont *wxSWISS_FONT;
+extern wxPen *wxRED_PEN;
+
+extern wxPen *wxCYAN_PEN;
+extern wxPen *wxGREEN_PEN;
+extern wxPen *wxBLACK_PEN;
+extern wxPen *wxWHITE_PEN;
+extern wxPen *wxTRANSPARENT_PEN;
+extern wxPen *wxBLACK_DASHED_PEN;
+extern wxPen *wxGREY_PEN;
+extern wxPen *wxMEDIUM_GREY_PEN;
+extern wxPen *wxLIGHT_GREY_PEN;
+
+extern wxBrush *wxBLUE_BRUSH;
+extern wxBrush *wxGREEN_BRUSH;
+extern wxBrush *wxWHITE_BRUSH;
+extern wxBrush *wxBLACK_BRUSH;
+extern wxBrush *wxTRANSPARENT_BRUSH;
+extern wxBrush *wxCYAN_BRUSH;
+extern wxBrush *wxRED_BRUSH;
+extern wxBrush *wxGREY_BRUSH;
+extern wxBrush *wxMEDIUM_GREY_BRUSH;
+extern wxBrush *wxLIGHT_GREY_BRUSH;
+
+extern wxColour *wxBLACK;
+extern wxColour *wxWHITE;
+extern wxColour *wxRED;
+extern wxColour *wxBLUE;
+extern wxColour *wxGREEN;
+extern wxColour *wxCYAN;
+extern wxColour *wxLIGHT_GREY;
+
+extern wxCursor *wxSTANDARD_CURSOR;
+extern wxCursor *wxHOURGLASS_CURSOR;
+extern wxCursor *wxCROSS_CURSOR;
+
+extern wxBitmap wxNullBitmap;
+extern wxIcon   wxNullIcon;
+extern wxCursor wxNullCursor;
+extern wxPen    wxNullPen;
+extern wxBrush  wxNullBrush;
+extern wxPalette wxNullPalette;
+extern wxFont   wxNullFont;
+extern wxColour wxNullColour;
+
+//---------------------------------------------------------------------------
+
+class wxPalette {
+public:
+    wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
+    ~wxPalette();
+
+    int GetPixel(byte red, byte green, byte blue);
+    bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
+    bool Ok();
+};
+
+//---------------------------------------------------------------------------
+
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.12  1999/01/30 07:30:11  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.11  1998/12/18 15:49:05  RR
+//
+//   wxClipboard now serves the primary selection as well
+//   wxPython fixes
+//   warning mesages
+//
+// Revision 1.10  1998/12/17 18:05:50  RD
+//
+// wxPython 0.5.2
+// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
+// versions are much closer now!
+//
+// Revision 1.9  1998/12/17 14:07:37  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.8  1998/12/16 22:10:54  RD
+//
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.7  1998/12/15 20:41:18  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.6  1998/11/25 08:45:24  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.5  1998/10/20 06:43:57  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.4  1998/10/02 06:40:38  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:16  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:35  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:50  RD
+// Initial version
+//
+//

utils/wxPython/src/gtk/cmndlgs.py

@@ -0,0 +1,592 @@
+# This file was created automatically by SWIG.
+import cmndlgsc
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+import wx
+class wxColourDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxColourData(self.this)
+    def GetChooseFull(self):
+        val = cmndlgsc.wxColourData_GetChooseFull(self.this)
+        return val
+    def GetColour(self):
+        val = cmndlgsc.wxColourData_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetCustomColour(self,arg0):
+        val = cmndlgsc.wxColourData_GetCustomColour(self.this,arg0)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def SetChooseFull(self,arg0):
+        val = cmndlgsc.wxColourData_SetChooseFull(self.this,arg0)
+        return val
+    def SetColour(self,arg0):
+        val = cmndlgsc.wxColourData_SetColour(self.this,arg0.this)
+        return val
+    def SetCustomColour(self,arg0,arg1):
+        val = cmndlgsc.wxColourData_SetCustomColour(self.this,arg0,arg1.this)
+        return val
+    def __repr__(self):
+        return "<C wxColourData instance>"
+class wxColourData(wxColourDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxColourData()
+        self.thisown = 1
+
+
+
+
+class wxColourDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetColourData(self):
+        val = cmndlgsc.wxColourDialog_GetColourData(self.this)
+        val = wxColourDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxColourDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxColourDialog instance>"
+class wxColourDialog(wxColourDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxColourDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxDirDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPath(self):
+        val = cmndlgsc.wxDirDialog_GetPath(self.this)
+        return val
+    def GetMessage(self):
+        val = cmndlgsc.wxDirDialog_GetMessage(self.this)
+        return val
+    def GetStyle(self):
+        val = cmndlgsc.wxDirDialog_GetStyle(self.this)
+        return val
+    def SetMessage(self,arg0):
+        val = cmndlgsc.wxDirDialog_SetMessage(self.this,arg0)
+        return val
+    def SetPath(self,arg0):
+        val = cmndlgsc.wxDirDialog_SetPath(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxDirDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDirDialog instance>"
+class wxDirDialog(wxDirDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[3] = argl[3].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxDirDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxFileDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetDirectory(self):
+        val = cmndlgsc.wxFileDialog_GetDirectory(self.this)
+        return val
+    def GetFilename(self):
+        val = cmndlgsc.wxFileDialog_GetFilename(self.this)
+        return val
+    def GetFilterIndex(self):
+        val = cmndlgsc.wxFileDialog_GetFilterIndex(self.this)
+        return val
+    def GetMessage(self):
+        val = cmndlgsc.wxFileDialog_GetMessage(self.this)
+        return val
+    def GetPath(self):
+        val = cmndlgsc.wxFileDialog_GetPath(self.this)
+        return val
+    def GetStyle(self):
+        val = cmndlgsc.wxFileDialog_GetStyle(self.this)
+        return val
+    def GetWildcard(self):
+        val = cmndlgsc.wxFileDialog_GetWildcard(self.this)
+        return val
+    def SetDirectory(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetDirectory(self.this,arg0)
+        return val
+    def SetFilename(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetFilename(self.this,arg0)
+        return val
+    def SetFilterIndex(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetFilterIndex(self.this,arg0)
+        return val
+    def SetMessage(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetMessage(self.this,arg0)
+        return val
+    def SetPath(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetPath(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetStyle(self.this,arg0)
+        return val
+    def SetWildcard(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetWildcard(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxFileDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxFileDialog instance>"
+class wxFileDialog(wxFileDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[5] = argl[5].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxFileDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxSingleChoiceDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSelection(self):
+        val = cmndlgsc.wxSingleChoiceDialog_GetSelection(self.this)
+        return val
+    def GetStringSelection(self):
+        val = cmndlgsc.wxSingleChoiceDialog_GetStringSelection(self.this)
+        return val
+    def SetSelection(self,arg0):
+        val = cmndlgsc.wxSingleChoiceDialog_SetSelection(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxSingleChoiceDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxSingleChoiceDialog instance>"
+class wxSingleChoiceDialog(wxSingleChoiceDialogPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,(arg0.this,arg1,arg2,arg3,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxTextEntryDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = cmndlgsc.wxTextEntryDialog_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = cmndlgsc.wxTextEntryDialog_SetValue(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxTextEntryDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTextEntryDialog instance>"
+class wxTextEntryDialog(wxTextEntryDialogPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[3] = argl[3].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxTextEntryDialog,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxFontDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxFontData(self.this)
+    def EnableEffects(self,arg0):
+        val = cmndlgsc.wxFontData_EnableEffects(self.this,arg0)
+        return val
+    def GetAllowSymbols(self):
+        val = cmndlgsc.wxFontData_GetAllowSymbols(self.this)
+        return val
+    def GetColour(self):
+        val = cmndlgsc.wxFontData_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetChosenFont(self):
+        val = cmndlgsc.wxFontData_GetChosenFont(self.this)
+        val = wxFontPtr(val)
+        val.thisown = 1
+        return val
+    def GetEnableEffects(self):
+        val = cmndlgsc.wxFontData_GetEnableEffects(self.this)
+        return val
+    def GetInitialFont(self):
+        val = cmndlgsc.wxFontData_GetInitialFont(self.this)
+        val = wxFontPtr(val)
+        val.thisown = 1
+        return val
+    def GetShowHelp(self):
+        val = cmndlgsc.wxFontData_GetShowHelp(self.this)
+        return val
+    def SetAllowSymbols(self,arg0):
+        val = cmndlgsc.wxFontData_SetAllowSymbols(self.this,arg0)
+        return val
+    def SetChosenFont(self,arg0):
+        val = cmndlgsc.wxFontData_SetChosenFont(self.this,arg0.this)
+        return val
+    def SetColour(self,arg0):
+        val = cmndlgsc.wxFontData_SetColour(self.this,arg0.this)
+        return val
+    def SetInitialFont(self,arg0):
+        val = cmndlgsc.wxFontData_SetInitialFont(self.this,arg0.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = cmndlgsc.wxFontData_SetRange(self.this,arg0,arg1)
+        return val
+    def SetShowHelp(self,arg0):
+        val = cmndlgsc.wxFontData_SetShowHelp(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxFontData instance>"
+class wxFontData(wxFontDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxFontData()
+        self.thisown = 1
+
+
+
+
+class wxFontDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFontData(self):
+        val = cmndlgsc.wxFontDialog_GetFontData(self.this)
+        val = wxFontDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxFontDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxFontDialog instance>"
+class wxFontDialog(wxFontDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxFontDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxPageSetupDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxPageSetupData(self.this)
+    def EnableHelp(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableHelp(self.this,arg0)
+        return val
+    def EnableMargins(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableMargins(self.this,arg0)
+        return val
+    def EnableOrientation(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableOrientation(self.this,arg0)
+        return val
+    def EnablePaper(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnablePaper(self.this,arg0)
+        return val
+    def EnablePrinter(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnablePrinter(self.this,arg0)
+        return val
+    def GetPaperSize(self):
+        val = cmndlgsc.wxPageSetupData_GetPaperSize(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMarginTopLeft(self):
+        val = cmndlgsc.wxPageSetupData_GetMarginTopLeft(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMarginBottomRight(self):
+        val = cmndlgsc.wxPageSetupData_GetMarginBottomRight(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMinMarginTopLeft(self):
+        val = cmndlgsc.wxPageSetupData_GetMinMarginTopLeft(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMinMarginBottomRight(self):
+        val = cmndlgsc.wxPageSetupData_GetMinMarginBottomRight(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetOrientation(self):
+        val = cmndlgsc.wxPageSetupData_GetOrientation(self.this)
+        return val
+    def GetDefaultMinMargins(self):
+        val = cmndlgsc.wxPageSetupData_GetDefaultMinMargins(self.this)
+        return val
+    def GetEnableMargins(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableMargins(self.this)
+        return val
+    def GetEnableOrientation(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableOrientation(self.this)
+        return val
+    def GetEnablePaper(self):
+        val = cmndlgsc.wxPageSetupData_GetEnablePaper(self.this)
+        return val
+    def GetEnablePrinter(self):
+        val = cmndlgsc.wxPageSetupData_GetEnablePrinter(self.this)
+        return val
+    def GetEnableHelp(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableHelp(self.this)
+        return val
+    def GetDefaultInfo(self):
+        val = cmndlgsc.wxPageSetupData_GetDefaultInfo(self.this)
+        return val
+    def SetPaperSize(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetPaperSize(self.this,arg0.this)
+        return val
+    def SetMarginTopLeft(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMarginTopLeft(self.this,arg0.this)
+        return val
+    def SetMarginBottomRight(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMarginBottomRight(self.this,arg0.this)
+        return val
+    def SetMinMarginTopLeft(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMinMarginTopLeft(self.this,arg0.this)
+        return val
+    def SetMinMarginBottomRight(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMinMarginBottomRight(self.this,arg0.this)
+        return val
+    def SetOrientation(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetOrientation(self.this,arg0)
+        return val
+    def SetDefaultMinMargins(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetDefaultMinMargins(self.this,arg0)
+        return val
+    def SetDefaultInfo(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetDefaultInfo(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPageSetupData instance>"
+class wxPageSetupData(wxPageSetupDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxPageSetupData()
+        self.thisown = 1
+
+
+
+
+class wxPageSetupDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPageSetupData(self):
+        val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this)
+        val = wxPageSetupDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPageSetupDialog instance>"
+class wxPageSetupDialog(wxPageSetupDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxPageSetupDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxPrintDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxPrintData(self.this)
+    def EnableHelp(self,arg0):
+        val = cmndlgsc.wxPrintData_EnableHelp(self.this,arg0)
+        return val
+    def EnablePageNumbers(self,arg0):
+        val = cmndlgsc.wxPrintData_EnablePageNumbers(self.this,arg0)
+        return val
+    def EnablePrintToFile(self,arg0):
+        val = cmndlgsc.wxPrintData_EnablePrintToFile(self.this,arg0)
+        return val
+    def EnableSelection(self,arg0):
+        val = cmndlgsc.wxPrintData_EnableSelection(self.this,arg0)
+        return val
+    def GetAllPages(self):
+        val = cmndlgsc.wxPrintData_GetAllPages(self.this)
+        return val
+    def GetCollate(self):
+        val = cmndlgsc.wxPrintData_GetCollate(self.this)
+        return val
+    def GetFromPage(self):
+        val = cmndlgsc.wxPrintData_GetFromPage(self.this)
+        return val
+    def GetMaxPage(self):
+        val = cmndlgsc.wxPrintData_GetMaxPage(self.this)
+        return val
+    def GetMinPage(self):
+        val = cmndlgsc.wxPrintData_GetMinPage(self.this)
+        return val
+    def GetNoCopies(self):
+        val = cmndlgsc.wxPrintData_GetNoCopies(self.this)
+        return val
+    def GetOrientation(self):
+        val = cmndlgsc.wxPrintData_GetOrientation(self.this)
+        return val
+    def GetToPage(self):
+        val = cmndlgsc.wxPrintData_GetToPage(self.this)
+        return val
+    def SetCollate(self,arg0):
+        val = cmndlgsc.wxPrintData_SetCollate(self.this,arg0)
+        return val
+    def SetFromPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetFromPage(self.this,arg0)
+        return val
+    def SetMaxPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetMaxPage(self.this,arg0)
+        return val
+    def SetMinPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetMinPage(self.this,arg0)
+        return val
+    def SetOrientation(self,arg0):
+        val = cmndlgsc.wxPrintData_SetOrientation(self.this,arg0)
+        return val
+    def SetNoCopies(self,arg0):
+        val = cmndlgsc.wxPrintData_SetNoCopies(self.this,arg0)
+        return val
+    def SetPrintToFile(self,arg0):
+        val = cmndlgsc.wxPrintData_SetPrintToFile(self.this,arg0)
+        return val
+    def SetSetupDialog(self,arg0):
+        val = cmndlgsc.wxPrintData_SetSetupDialog(self.this,arg0)
+        return val
+    def SetToPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetToPage(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPrintData instance>"
+class wxPrintData(wxPrintDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxPrintData()
+        self.thisown = 1
+
+
+
+
+class wxPrintDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPrintData(self):
+        val = cmndlgsc.wxPrintDialog_GetPrintData(self.this)
+        val = wxPrintDataPtr(val)
+        return val
+    def GetPrintDC(self):
+        val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this)
+        val = wxDCPtr(val)
+        val.thisown = 1
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxPrintDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPrintDialog instance>"
+class wxPrintDialog(wxPrintDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxPrintDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxMessageDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ShowModal(self):
+        val = cmndlgsc.wxMessageDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMessageDialog instance>"
+class wxMessageDialog(wxMessageDialogPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxMessageDialog,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/controls.py

@@ -0,0 +1,836 @@
+# This file was created automatically by SWIG.
+import controlsc
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from events import *
+import wx
+class wxControlPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Command(self,arg0):
+        val = controlsc.wxControl_Command(self.this,arg0.this)
+        return val
+    def GetLabel(self):
+        val = controlsc.wxControl_GetLabel(self.this)
+        return val
+    def SetLabel(self,arg0):
+        val = controlsc.wxControl_SetLabel(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxControl instance>"
+class wxControl(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetDefault(self):
+        val = controlsc.wxButton_SetDefault(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxButton instance>"
+class wxButton(wxButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxButton,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxBitmapButtonPtr(wxButtonPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBitmapLabel(self):
+        val = controlsc.wxBitmapButton_GetBitmapLabel(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapDisabled(self):
+        val = controlsc.wxBitmapButton_GetBitmapDisabled(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapFocus(self):
+        val = controlsc.wxBitmapButton_GetBitmapFocus(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapSelected(self):
+        val = controlsc.wxBitmapButton_GetBitmapSelected(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetBitmapDisabled(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapDisabled(self.this,arg0.this)
+        return val
+    def SetBitmapFocus(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapFocus(self.this,arg0.this)
+        return val
+    def SetBitmapSelected(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapSelected(self.this,arg0.this)
+        return val
+    def SetBitmapLabel(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapLabel(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxBitmapButton instance>"
+class wxBitmapButton(wxBitmapButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxBitmapButton,(arg0.this,arg1,arg2.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxCheckBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = controlsc.wxCheckBox_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxCheckBox_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxCheckBox instance>"
+class wxCheckBox(wxCheckBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxCheckBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxChoicePtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxChoice_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxChoice_Clear(self.this)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxChoice_FindString(self.this,arg0)
+        return val
+    def GetColumns(self):
+        val = controlsc.wxChoice_GetColumns(self.this)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxChoice_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxChoice_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxChoice_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxChoice_Number(self.this)
+        return val
+    def SetColumns(self,*args):
+        val = apply(controlsc.wxChoice_SetColumns,(self.this,)+args)
+        return val
+    def SetSelection(self,arg0):
+        val = controlsc.wxChoice_SetSelection(self.this,arg0)
+        return val
+    def SetStringSelection(self,arg0):
+        val = controlsc.wxChoice_SetStringSelection(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxChoice instance>"
+class wxChoice(wxChoicePtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxChoice,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxComboBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxComboBox_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxComboBox_Clear(self.this)
+        return val
+    def Copy(self):
+        val = controlsc.wxComboBox_Copy(self.this)
+        return val
+    def Cut(self):
+        val = controlsc.wxComboBox_Cut(self.this)
+        return val
+    def Delete(self,arg0):
+        val = controlsc.wxComboBox_Delete(self.this,arg0)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxComboBox_FindString(self.this,arg0)
+        return val
+    def GetInsertionPoint(self):
+        val = controlsc.wxComboBox_GetInsertionPoint(self.this)
+        return val
+    def GetLastPosition(self):
+        val = controlsc.wxComboBox_GetLastPosition(self.this)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxComboBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxComboBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxComboBox_GetStringSelection(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxComboBox_GetValue(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxComboBox_Number(self.this)
+        return val
+    def Paste(self):
+        val = controlsc.wxComboBox_Paste(self.this)
+        return val
+    def Replace(self,arg0,arg1,arg2):
+        val = controlsc.wxComboBox_Replace(self.this,arg0,arg1,arg2)
+        return val
+    def Remove(self,arg0,arg1):
+        val = controlsc.wxComboBox_Remove(self.this,arg0,arg1)
+        return val
+    def SetInsertionPoint(self,arg0):
+        val = controlsc.wxComboBox_SetInsertionPoint(self.this,arg0)
+        return val
+    def SetInsertionPointEnd(self):
+        val = controlsc.wxComboBox_SetInsertionPointEnd(self.this)
+        return val
+    def SetSelection(self,arg0,*args):
+        val = apply(controlsc.wxComboBox_SetSelection,(self.this,arg0,)+args)
+        return val
+    def SetMark(self,arg0,arg1):
+        val = controlsc.wxComboBox_SetMark(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxComboBox_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxComboBox instance>"
+class wxComboBox(wxComboBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxComboBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxGaugePtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBezelFace(self):
+        val = controlsc.wxGauge_GetBezelFace(self.this)
+        return val
+    def GetRange(self):
+        val = controlsc.wxGauge_GetRange(self.this)
+        return val
+    def GetShadowWidth(self):
+        val = controlsc.wxGauge_GetShadowWidth(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxGauge_GetValue(self.this)
+        return val
+    def SetBezelFace(self,arg0):
+        val = controlsc.wxGauge_SetBezelFace(self.this,arg0)
+        return val
+    def SetRange(self,arg0):
+        val = controlsc.wxGauge_SetRange(self.this,arg0)
+        return val
+    def SetShadowWidth(self,arg0):
+        val = controlsc.wxGauge_SetShadowWidth(self.this,arg0)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxGauge_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxGauge instance>"
+class wxGauge(wxGaugePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxGauge,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxStaticBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxStaticBox instance>"
+class wxStaticBox(wxStaticBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+
+
+
+
+class wxStaticTextPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetLabel(self):
+        val = controlsc.wxStaticText_GetLabel(self.this)
+        return val
+    def SetLabel(self,arg0):
+        val = controlsc.wxStaticText_SetLabel(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxStaticText instance>"
+class wxStaticText(wxStaticTextPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticText,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxListBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxListBox_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxListBox_Clear(self.this)
+        return val
+    def Delete(self,arg0):
+        val = controlsc.wxListBox_Delete(self.this,arg0)
+        return val
+    def Deselect(self,arg0):
+        val = controlsc.wxListBox_Deselect(self.this,arg0)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxListBox_FindString(self.this,arg0)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxListBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxListBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxListBox_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxListBox_Number(self.this)
+        return val
+    def Selected(self,arg0):
+        val = controlsc.wxListBox_Selected(self.this,arg0)
+        return val
+    def Set(self,arg0,*args):
+        val = apply(controlsc.wxListBox_Set,(self.this,arg0,)+args)
+        return val
+    def SetFirstItem(self,arg0):
+        val = controlsc.wxListBox_SetFirstItem(self.this,arg0)
+        return val
+    def SetFirstItemStr(self,arg0):
+        val = controlsc.wxListBox_SetFirstItemStr(self.this,arg0)
+        return val
+    def SetSelection(self,arg0,*args):
+        val = apply(controlsc.wxListBox_SetSelection,(self.this,arg0,)+args)
+        return val
+    def SetString(self,arg0,arg1):
+        val = controlsc.wxListBox_SetString(self.this,arg0,arg1)
+        return val
+    def SetStringSelection(self,arg0,*args):
+        val = apply(controlsc.wxListBox_SetStringSelection,(self.this,arg0,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxListBox instance>"
+class wxListBox(wxListBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxListBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxCheckListBoxPtr(wxListBoxPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsChecked(self,arg0):
+        val = controlsc.wxCheckListBox_IsChecked(self.this,arg0)
+        return val
+    def Check(self,arg0,*args):
+        val = apply(controlsc.wxCheckListBox_Check,(self.this,arg0,)+args)
+        return val
+    def GetItemHeight(self):
+        val = controlsc.wxCheckListBox_GetItemHeight(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCheckListBox instance>"
+class wxCheckListBox(wxCheckListBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxCheckListBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxTextCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Clear(self):
+        val = controlsc.wxTextCtrl_Clear(self.this)
+        return val
+    def Copy(self):
+        val = controlsc.wxTextCtrl_Copy(self.this)
+        return val
+    def Cut(self):
+        val = controlsc.wxTextCtrl_Cut(self.this)
+        return val
+    def DiscardEdits(self):
+        val = controlsc.wxTextCtrl_DiscardEdits(self.this)
+        return val
+    def GetInsertionPoint(self):
+        val = controlsc.wxTextCtrl_GetInsertionPoint(self.this)
+        return val
+    def GetLastPosition(self):
+        val = controlsc.wxTextCtrl_GetLastPosition(self.this)
+        return val
+    def GetLineLength(self,arg0):
+        val = controlsc.wxTextCtrl_GetLineLength(self.this,arg0)
+        return val
+    def GetLineText(self,arg0):
+        val = controlsc.wxTextCtrl_GetLineText(self.this,arg0)
+        return val
+    def GetNumberOfLines(self):
+        val = controlsc.wxTextCtrl_GetNumberOfLines(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxTextCtrl_GetValue(self.this)
+        return val
+    def IsModified(self):
+        val = controlsc.wxTextCtrl_IsModified(self.this)
+        return val
+    def LoadFile(self,arg0):
+        val = controlsc.wxTextCtrl_LoadFile(self.this,arg0)
+        return val
+    def Paste(self):
+        val = controlsc.wxTextCtrl_Paste(self.this)
+        return val
+    def PositionToXY(self,arg0):
+        val = controlsc.wxTextCtrl_PositionToXY(self.this,arg0)
+        return val
+    def Remove(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_Remove(self.this,arg0,arg1)
+        return val
+    def Replace(self,arg0,arg1,arg2):
+        val = controlsc.wxTextCtrl_Replace(self.this,arg0,arg1,arg2)
+        return val
+    def SaveFile(self,arg0):
+        val = controlsc.wxTextCtrl_SaveFile(self.this,arg0)
+        return val
+    def SetEditable(self,arg0):
+        val = controlsc.wxTextCtrl_SetEditable(self.this,arg0)
+        return val
+    def SetInsertionPoint(self,arg0):
+        val = controlsc.wxTextCtrl_SetInsertionPoint(self.this,arg0)
+        return val
+    def SetInsertionPointEnd(self):
+        val = controlsc.wxTextCtrl_SetInsertionPointEnd(self.this)
+        return val
+    def SetSelection(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_SetSelection(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxTextCtrl_SetValue(self.this,arg0)
+        return val
+    def ShowPosition(self,arg0):
+        val = controlsc.wxTextCtrl_ShowPosition(self.this,arg0)
+        return val
+    def WriteText(self,arg0):
+        val = controlsc.wxTextCtrl_WriteText(self.this,arg0)
+        return val
+    def XYToPosition(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_XYToPosition(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxTextCtrl instance>"
+class wxTextCtrl(wxTextCtrlPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxTextCtrl,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxScrollBarPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetRange(self):
+        val = controlsc.wxScrollBar_GetRange(self.this)
+        return val
+    def GetPageSize(self):
+        val = controlsc.wxScrollBar_GetPageSize(self.this)
+        return val
+    def GetThumbPosition(self):
+        val = controlsc.wxScrollBar_GetThumbPosition(self.this)
+        return val
+    def GetThumbSize(self):
+        val = controlsc.wxScrollBar_GetThumbSize(self.this)
+        return val
+    def SetThumbPosition(self,arg0):
+        val = controlsc.wxScrollBar_SetThumbPosition(self.this,arg0)
+        return val
+    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(controlsc.wxScrollBar_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxScrollBar instance>"
+class wxScrollBar(wxScrollBarPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxScrollBar,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSpinButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetMax(self):
+        val = controlsc.wxSpinButton_GetMax(self.this)
+        return val
+    def GetMin(self):
+        val = controlsc.wxSpinButton_GetMin(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxSpinButton_GetValue(self.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = controlsc.wxSpinButton_SetRange(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxSpinButton_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSpinButton instance>"
+class wxSpinButton(wxSpinButtonPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxSpinButton,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxStaticBitmapPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBitmap(self):
+        val = controlsc.wxStaticBitmap_GetBitmap(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetBitmap(self,arg0):
+        val = controlsc.wxStaticBitmap_SetBitmap(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxStaticBitmap instance>"
+class wxStaticBitmap(wxStaticBitmapPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticBitmap,(arg0.this,arg1,arg2.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxRadioBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def EnableBox(self,arg0):
+        val = controlsc.wxRadioBox_EnableBox(self.this,arg0)
+        return val
+    def Enable(self,arg0,arg1):
+        val = controlsc.wxRadioBox_Enable(self.this,arg0,arg1)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxRadioBox_FindString(self.this,arg0)
+        return val
+    def GetLabel(self,arg0):
+        val = controlsc.wxRadioBox_GetLabel(self.this,arg0)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxRadioBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxRadioBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxRadioBox_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxRadioBox_Number(self.this)
+        return val
+    def SetBoxLabel(self,arg0):
+        val = controlsc.wxRadioBox_SetBoxLabel(self.this,arg0)
+        return val
+    def SetLabel(self,arg0,arg1):
+        val = controlsc.wxRadioBox_SetLabel(self.this,arg0,arg1)
+        return val
+    def SetSelection(self,arg0):
+        val = controlsc.wxRadioBox_SetSelection(self.this,arg0)
+        return val
+    def SetStringSelection(self,arg0):
+        val = controlsc.wxRadioBox_SetStringSelection(self.this,arg0)
+        return val
+    def Show(self,arg0):
+        val = controlsc.wxRadioBox_Show(self.this,arg0)
+        return val
+    def ShowItem(self,arg0,arg1):
+        val = controlsc.wxRadioBox_ShowItem(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxRadioBox instance>"
+class wxRadioBox(wxRadioBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxRadioBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxRadioButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = controlsc.wxRadioButton_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxRadioButton_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxRadioButton instance>"
+class wxRadioButton(wxRadioButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxRadioButton,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSliderPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ClearSel(self):
+        val = controlsc.wxSlider_ClearSel(self.this)
+        return val
+    def ClearTicks(self):
+        val = controlsc.wxSlider_ClearTicks(self.this)
+        return val
+    def GetLineSize(self):
+        val = controlsc.wxSlider_GetLineSize(self.this)
+        return val
+    def GetMax(self):
+        val = controlsc.wxSlider_GetMax(self.this)
+        return val
+    def GetMin(self):
+        val = controlsc.wxSlider_GetMin(self.this)
+        return val
+    def GetPageSize(self):
+        val = controlsc.wxSlider_GetPageSize(self.this)
+        return val
+    def GetSelEnd(self):
+        val = controlsc.wxSlider_GetSelEnd(self.this)
+        return val
+    def GetSelStart(self):
+        val = controlsc.wxSlider_GetSelStart(self.this)
+        return val
+    def GetThumbLength(self):
+        val = controlsc.wxSlider_GetThumbLength(self.this)
+        return val
+    def GetTickFreq(self):
+        val = controlsc.wxSlider_GetTickFreq(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxSlider_GetValue(self.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = controlsc.wxSlider_SetRange(self.this,arg0,arg1)
+        return val
+    def SetTickFreq(self,arg0,arg1):
+        val = controlsc.wxSlider_SetTickFreq(self.this,arg0,arg1)
+        return val
+    def SetLineSize(self,arg0):
+        val = controlsc.wxSlider_SetLineSize(self.this,arg0)
+        return val
+    def SetPageSize(self,arg0):
+        val = controlsc.wxSlider_SetPageSize(self.this,arg0)
+        return val
+    def SetSelection(self,arg0,arg1):
+        val = controlsc.wxSlider_SetSelection(self.this,arg0,arg1)
+        return val
+    def SetThumbLength(self,arg0):
+        val = controlsc.wxSlider_SetThumbLength(self.this,arg0)
+        return val
+    def SetTick(self,arg0):
+        val = controlsc.wxSlider_SetTick(self.this,arg0)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxSlider_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSlider instance>"
+class wxSlider(wxSliderPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,arg4,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxSlider,(arg0.this,arg1,arg2,arg3,arg4,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/controls2.py

@@ -0,0 +1,606 @@
+# This file was created automatically by SWIG.
+import controls2c
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from events import *
+
+from controls import *
+import wx
+class wxListItemPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxListItem(self.this)
+    def __setattr__(self,name,value):
+        if name == "m_mask" :
+            controls2c.wxListItem_m_mask_set(self.this,value)
+            return
+        if name == "m_itemId" :
+            controls2c.wxListItem_m_itemId_set(self.this,value)
+            return
+        if name == "m_col" :
+            controls2c.wxListItem_m_col_set(self.this,value)
+            return
+        if name == "m_state" :
+            controls2c.wxListItem_m_state_set(self.this,value)
+            return
+        if name == "m_stateMask" :
+            controls2c.wxListItem_m_stateMask_set(self.this,value)
+            return
+        if name == "m_text" :
+            controls2c.wxListItem_m_text_set(self.this,value)
+            return
+        if name == "m_image" :
+            controls2c.wxListItem_m_image_set(self.this,value)
+            return
+        if name == "m_data" :
+            controls2c.wxListItem_m_data_set(self.this,value)
+            return
+        if name == "m_format" :
+            controls2c.wxListItem_m_format_set(self.this,value)
+            return
+        if name == "m_width" :
+            controls2c.wxListItem_m_width_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_mask" : 
+            return controls2c.wxListItem_m_mask_get(self.this)
+        if name == "m_itemId" : 
+            return controls2c.wxListItem_m_itemId_get(self.this)
+        if name == "m_col" : 
+            return controls2c.wxListItem_m_col_get(self.this)
+        if name == "m_state" : 
+            return controls2c.wxListItem_m_state_get(self.this)
+        if name == "m_stateMask" : 
+            return controls2c.wxListItem_m_stateMask_get(self.this)
+        if name == "m_text" : 
+            return controls2c.wxListItem_m_text_get(self.this)
+        if name == "m_image" : 
+            return controls2c.wxListItem_m_image_get(self.this)
+        if name == "m_data" : 
+            return controls2c.wxListItem_m_data_get(self.this)
+        if name == "m_format" : 
+            return controls2c.wxListItem_m_format_get(self.this)
+        if name == "m_width" : 
+            return controls2c.wxListItem_m_width_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxListItem instance>"
+class wxListItem(wxListItemPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxListItem()
+        self.thisown = 1
+
+
+
+
+class wxListEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __setattr__(self,name,value):
+        if name == "m_code" :
+            controls2c.wxListEvent_m_code_set(self.this,value)
+            return
+        if name == "m_itemIndex" :
+            controls2c.wxListEvent_m_itemIndex_set(self.this,value)
+            return
+        if name == "m_oldItemIndex" :
+            controls2c.wxListEvent_m_oldItemIndex_set(self.this,value)
+            return
+        if name == "m_col" :
+            controls2c.wxListEvent_m_col_set(self.this,value)
+            return
+        if name == "m_cancelled" :
+            controls2c.wxListEvent_m_cancelled_set(self.this,value)
+            return
+        if name == "m_pointDrag" :
+            controls2c.wxListEvent_m_pointDrag_set(self.this,value.this)
+            return
+        if name == "m_item" :
+            controls2c.wxListEvent_m_item_set(self.this,value.this)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_code" : 
+            return controls2c.wxListEvent_m_code_get(self.this)
+        if name == "m_itemIndex" : 
+            return controls2c.wxListEvent_m_itemIndex_get(self.this)
+        if name == "m_oldItemIndex" : 
+            return controls2c.wxListEvent_m_oldItemIndex_get(self.this)
+        if name == "m_col" : 
+            return controls2c.wxListEvent_m_col_get(self.this)
+        if name == "m_cancelled" : 
+            return controls2c.wxListEvent_m_cancelled_get(self.this)
+        if name == "m_pointDrag" : 
+            return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self.this))
+        if name == "m_item" : 
+            return wxListItemPtr(controls2c.wxListEvent_m_item_get(self.this))
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxListEvent instance>"
+class wxListEvent(wxListEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxListCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Arrange(self,*args):
+        val = apply(controls2c.wxListCtrl_Arrange,(self.this,)+args)
+        return val
+    def DeleteItem(self,arg0):
+        val = controls2c.wxListCtrl_DeleteItem(self.this,arg0)
+        return val
+    def DeleteAllItems(self):
+        val = controls2c.wxListCtrl_DeleteAllItems(self.this)
+        return val
+    def DeleteColumn(self,arg0):
+        val = controls2c.wxListCtrl_DeleteColumn(self.this,arg0)
+        return val
+    def DeleteAllColumns(self):
+        val = controls2c.wxListCtrl_DeleteAllColumns(self.this)
+        return val
+    def ClearAll(self):
+        val = controls2c.wxListCtrl_ClearAll(self.this)
+        return val
+    def EnsureVisible(self,arg0):
+        val = controls2c.wxListCtrl_EnsureVisible(self.this,arg0)
+        return val
+    def FindItem(self,arg0,arg1,*args):
+        val = apply(controls2c.wxListCtrl_FindItem,(self.this,arg0,arg1,)+args)
+        return val
+    def FindItemData(self,arg0,arg1):
+        val = controls2c.wxListCtrl_FindItemData(self.this,arg0,arg1)
+        return val
+    def FindItemAtPos(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_FindItemAtPos(self.this,arg0,arg1.this,arg2)
+        return val
+    def GetColumn(self,arg0,arg1):
+        val = controls2c.wxListCtrl_GetColumn(self.this,arg0,arg1.this)
+        return val
+    def GetColumnWidth(self,arg0):
+        val = controls2c.wxListCtrl_GetColumnWidth(self.this,arg0)
+        return val
+    def GetCountPerPage(self):
+        val = controls2c.wxListCtrl_GetCountPerPage(self.this)
+        return val
+    def GetImageList(self,arg0):
+        val = controls2c.wxListCtrl_GetImageList(self.this,arg0)
+        return val
+    def GetItemData(self,arg0):
+        val = controls2c.wxListCtrl_GetItemData(self.this,arg0)
+        return val
+    def GetItem(self):
+        val = controls2c.wxListCtrl_GetItem(self.this)
+        val = wxListItemPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemPosition(self,arg0):
+        val = controls2c.wxListCtrl_GetItemPosition(self.this,arg0)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemRect(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_GetItemRect,(self.this,arg0,)+args)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemState(self,arg0,arg1):
+        val = controls2c.wxListCtrl_GetItemState(self.this,arg0,arg1)
+        return val
+    def GetItemCount(self):
+        val = controls2c.wxListCtrl_GetItemCount(self.this)
+        return val
+    def GetItemSpacing(self,arg0):
+        val = controls2c.wxListCtrl_GetItemSpacing(self.this,arg0)
+        return val
+    def GetItemText(self,arg0):
+        val = controls2c.wxListCtrl_GetItemText(self.this,arg0)
+        return val
+    def GetNextItem(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_GetNextItem,(self.this,arg0,)+args)
+        return val
+    def GetSelectedItemCount(self):
+        val = controls2c.wxListCtrl_GetSelectedItemCount(self.this)
+        return val
+    def GetTopItem(self):
+        val = controls2c.wxListCtrl_GetTopItem(self.this)
+        return val
+    def HitTest(self,arg0):
+        val = controls2c.wxListCtrl_HitTest(self.this,arg0.this)
+        return val
+    def InsertColumnWithInfo(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertColumnWithInfo(self.this,arg0,arg1.this)
+        return val
+    def InsertColumn(self,arg0,arg1,*args):
+        val = apply(controls2c.wxListCtrl_InsertColumn,(self.this,arg0,arg1,)+args)
+        return val
+    def InsertItem(self,arg0):
+        val = controls2c.wxListCtrl_InsertItem(self.this,arg0.this)
+        return val
+    def InsertStringItem(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertStringItem(self.this,arg0,arg1)
+        return val
+    def InsertImageItem(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertImageItem(self.this,arg0,arg1)
+        return val
+    def InsertImageStringItem(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_InsertImageStringItem(self.this,arg0,arg1,arg2)
+        return val
+    def ScrollList(self,arg0,arg1):
+        val = controls2c.wxListCtrl_ScrollList(self.this,arg0,arg1)
+        return val
+    def SetBackgroundColour(self,arg0):
+        val = controls2c.wxListCtrl_SetBackgroundColour(self.this,arg0.this)
+        return val
+    def SetColumn(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetColumn(self.this,arg0,arg1.this)
+        return val
+    def SetColumnWidth(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetColumnWidth(self.this,arg0,arg1)
+        return val
+    def SetImageList(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetImageList(self.this,arg0,arg1)
+        return val
+    def SetItem(self,arg0):
+        val = controls2c.wxListCtrl_SetItem(self.this,arg0.this)
+        return val
+    def SetItemString(self,arg0,arg1,arg2,*args):
+        val = apply(controls2c.wxListCtrl_SetItemString,(self.this,arg0,arg1,arg2,)+args)
+        return val
+    def SetItemData(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemData(self.this,arg0,arg1)
+        return val
+    def SetItemImage(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_SetItemImage(self.this,arg0,arg1,arg2)
+        return val
+    def SetItemPosition(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemPosition(self.this,arg0,arg1.this)
+        return val
+    def SetItemState(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_SetItemState(self.this,arg0,arg1,arg2)
+        return val
+    def SetItemText(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemText(self.this,arg0,arg1)
+        return val
+    def SetSingleStyle(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_SetSingleStyle,(self.this,arg0,)+args)
+        return val
+    def SetWindowStyleFlag(self,arg0):
+        val = controls2c.wxListCtrl_SetWindowStyleFlag(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxListCtrl instance>"
+class wxListCtrl(wxListCtrlPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controls2c.new_wxListCtrl,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxTreeItemIdPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxTreeItemId(self.this)
+    def IsOk(self):
+        val = controls2c.wxTreeItemId_IsOk(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeItemId instance>"
+class wxTreeItemId(wxTreeItemIdPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxTreeItemId()
+        self.thisown = 1
+
+
+
+
+class wxTreeItemDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxTreeItemData(self.this)
+    def GetId(self):
+        val = controls2c.wxTreeItemData_GetId(self.this)
+        val = wxTreeItemIdPtr(val)
+        return val
+    def SetId(self,arg0):
+        val = controls2c.wxTreeItemData_SetId(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeItemData instance>"
+class wxTreeItemData(wxTreeItemDataPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxTreeItemData()
+        self.thisown = 1
+
+
+
+
+class wxTreeEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetItem(self):
+        val = controls2c.wxTreeEvent_GetItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetOldItem(self):
+        val = controls2c.wxTreeEvent_GetOldItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPoint(self):
+        val = controls2c.wxTreeEvent_GetPoint(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetCode(self):
+        val = controls2c.wxTreeEvent_GetCode(self.this)
+        return val
+    def Veto(self):
+        val = controls2c.wxTreeEvent_Veto(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeEvent instance>"
+class wxTreeEvent(wxTreeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxTreeCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetCount(self):
+        val = controls2c.wxTreeCtrl_GetCount(self.this)
+        return val
+    def GetIndent(self):
+        val = controls2c.wxTreeCtrl_GetIndent(self.this)
+        return val
+    def SetIndent(self,arg0):
+        val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
+        return val
+    def GetImageList(self):
+        val = controls2c.wxTreeCtrl_GetImageList(self.this)
+        return val
+    def GetStateImageList(self):
+        val = controls2c.wxTreeCtrl_GetStateImageList(self.this)
+        return val
+    def SetImageList(self,arg0):
+        val = controls2c.wxTreeCtrl_SetImageList(self.this,arg0)
+        return val
+    def SetStateImageList(self,arg0):
+        val = controls2c.wxTreeCtrl_SetStateImageList(self.this,arg0)
+        return val
+    def GetItemText(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0.this)
+        return val
+    def GetItemImage(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemImage(self.this,arg0.this)
+        return val
+    def GetItemSelectedImage(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this)
+        return val
+    def GetItemData(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this)
+        val = wxTreeItemDataPtr(val)
+        return val
+    def SetItemText(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1)
+        return val
+    def SetItemImage(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0.this,arg1)
+        return val
+    def SetItemSelectedImage(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1)
+        return val
+    def SetItemData(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this)
+        return val
+    def SetItemHasChildren(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args)
+        return val
+    def IsVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this)
+        return val
+    def ItemHasChildren(self,arg0):
+        val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0.this)
+        return val
+    def IsExpanded(self,arg0):
+        val = controls2c.wxTreeCtrl_IsExpanded(self.this,arg0.this)
+        return val
+    def IsSelected(self,arg0):
+        val = controls2c.wxTreeCtrl_IsSelected(self.this,arg0.this)
+        return val
+    def GetRootItem(self):
+        val = controls2c.wxTreeCtrl_GetRootItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetSelection(self):
+        val = controls2c.wxTreeCtrl_GetSelection(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetParent(self,arg0):
+        val = controls2c.wxTreeCtrl_GetParent(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetFirstChild(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
+        return val
+    def GetNextChild(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
+        return val
+    def GetNextSibling(self,arg0):
+        val = controls2c.wxTreeCtrl_GetNextSibling(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPrevSibling(self,arg0):
+        val = controls2c.wxTreeCtrl_GetPrevSibling(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetFirstVisibleItem(self):
+        val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetNextVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_GetNextVisible(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPrevVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_GetPrevVisible(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def AddRoot(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_AddRoot,(self.this,arg0,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def PrependItem(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_PrependItem,(self.this,arg0.this,arg1,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def InsertItem(self,arg0,arg1,arg2,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0.this,arg1.this,arg2,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def AppendItem(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_AppendItem,(self.this,arg0.this,arg1,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def Delete(self,arg0):
+        val = controls2c.wxTreeCtrl_Delete(self.this,arg0.this)
+        return val
+    def DeleteChildren(self,arg0):
+        val = controls2c.wxTreeCtrl_DeleteChildren(self.this,arg0.this)
+        return val
+    def DeleteAllItems(self):
+        val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
+        return val
+    def Expand(self,arg0):
+        val = controls2c.wxTreeCtrl_Expand(self.this,arg0.this)
+        return val
+    def Collapse(self,arg0):
+        val = controls2c.wxTreeCtrl_Collapse(self.this,arg0.this)
+        return val
+    def CollapseAndReset(self,arg0):
+        val = controls2c.wxTreeCtrl_CollapseAndReset(self.this,arg0.this)
+        return val
+    def Toggle(self,arg0):
+        val = controls2c.wxTreeCtrl_Toggle(self.this,arg0.this)
+        return val
+    def Unselect(self):
+        val = controls2c.wxTreeCtrl_Unselect(self.this)
+        return val
+    def SelectItem(self,arg0):
+        val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0.this)
+        return val
+    def EnsureVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0.this)
+        return val
+    def ScrollTo(self,arg0):
+        val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0.this)
+        return val
+    def EditLabel(self,arg0):
+        val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def GetEditControl(self):
+        val = controls2c.wxTreeCtrl_GetEditControl(self.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def EndEditLabel(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_EndEditLabel,(self.this,arg0.this,)+args)
+        return val
+    def SetItemBold(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_SetItemBold,(self.this,arg0.this,)+args)
+        return val
+    def IsBold(self,arg0):
+        val = controls2c.wxTreeCtrl_IsBold(self.this,arg0.this)
+        return val
+    def HitTest(self,arg0):
+        val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxTreeCtrl instance>"
+class wxTreeCtrl(wxTreeCtrlPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controls2c.new_wxTreeCtrl,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/events.py

@@ -0,0 +1,630 @@
+# This file was created automatically by SWIG.
+import eventsc
+
+from misc import *
+class wxEventPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetEventObject(self):
+        val = eventsc.wxEvent_GetEventObject(self.this)
+        return val
+    def GetEventType(self):
+        val = eventsc.wxEvent_GetEventType(self.this)
+        return val
+    def GetId(self):
+        val = eventsc.wxEvent_GetId(self.this)
+        return val
+    def GetSkipped(self):
+        val = eventsc.wxEvent_GetSkipped(self.this)
+        return val
+    def GetTimestamp(self):
+        val = eventsc.wxEvent_GetTimestamp(self.this)
+        return val
+    def SetEventObject(self,arg0):
+        val = eventsc.wxEvent_SetEventObject(self.this,arg0)
+        return val
+    def SetEventType(self,arg0):
+        val = eventsc.wxEvent_SetEventType(self.this,arg0)
+        return val
+    def SetId(self,arg0):
+        val = eventsc.wxEvent_SetId(self.this,arg0)
+        return val
+    def SetTimestamp(self,arg0):
+        val = eventsc.wxEvent_SetTimestamp(self.this,arg0)
+        return val
+    def Skip(self,*args):
+        val = apply(eventsc.wxEvent_Skip,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxEvent instance>"
+class wxEvent(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSize(self):
+        val = eventsc.wxSizeEvent_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxSizeEvent instance>"
+class wxSizeEvent(wxSizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCloseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def CanVeto(self):
+        val = eventsc.wxCloseEvent_CanVeto(self.this)
+        return val
+    def GetLoggingOff(self):
+        val = eventsc.wxCloseEvent_GetLoggingOff(self.this)
+        return val
+    def Veto(self,*args):
+        val = apply(eventsc.wxCloseEvent_Veto,(self.this,)+args)
+        return val
+    def GetVeto(self):
+        val = eventsc.wxCloseEvent_GetVeto(self.this)
+        return val
+    def SetForce(self,arg0):
+        val = eventsc.wxCloseEvent_SetForce(self.this,arg0)
+        return val
+    def SetCanVeto(self,arg0):
+        val = eventsc.wxCloseEvent_SetCanVeto(self.this,arg0)
+        return val
+    def SetLoggingOff(self,arg0):
+        val = eventsc.wxCloseEvent_SetLoggingOff(self.this,arg0)
+        return val
+    def GetForce(self):
+        val = eventsc.wxCloseEvent_GetForce(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCloseEvent instance>"
+class wxCloseEvent(wxCloseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCommandEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Checked(self):
+        val = eventsc.wxCommandEvent_Checked(self.this)
+        return val
+    def GetExtraLong(self):
+        val = eventsc.wxCommandEvent_GetExtraLong(self.this)
+        return val
+    def GetInt(self):
+        val = eventsc.wxCommandEvent_GetInt(self.this)
+        return val
+    def GetSelection(self):
+        val = eventsc.wxCommandEvent_GetSelection(self.this)
+        return val
+    def GetString(self):
+        val = eventsc.wxCommandEvent_GetString(self.this)
+        return val
+    def IsSelection(self):
+        val = eventsc.wxCommandEvent_IsSelection(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCommandEvent instance>"
+class wxCommandEvent(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxScrollEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetOrientation(self):
+        val = eventsc.wxScrollEvent_GetOrientation(self.this)
+        return val
+    def GetPosition(self):
+        val = eventsc.wxScrollEvent_GetPosition(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScrollEvent instance>"
+class wxScrollEvent(wxScrollEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSpinEventPtr(wxScrollEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxSpinEvent instance>"
+class wxSpinEvent(wxSpinEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMouseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsButton(self):
+        val = eventsc.wxMouseEvent_IsButton(self.this)
+        return val
+    def ButtonDown(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonDown,(self.this,)+args)
+        return val
+    def ButtonDClick(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonDClick,(self.this,)+args)
+        return val
+    def ButtonUp(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonUp,(self.this,)+args)
+        return val
+    def Button(self,arg0):
+        val = eventsc.wxMouseEvent_Button(self.this,arg0)
+        return val
+    def ButtonIsDown(self,arg0):
+        val = eventsc.wxMouseEvent_ButtonIsDown(self.this,arg0)
+        return val
+    def ControlDown(self):
+        val = eventsc.wxMouseEvent_ControlDown(self.this)
+        return val
+    def MetaDown(self):
+        val = eventsc.wxMouseEvent_MetaDown(self.this)
+        return val
+    def AltDown(self):
+        val = eventsc.wxMouseEvent_AltDown(self.this)
+        return val
+    def ShiftDown(self):
+        val = eventsc.wxMouseEvent_ShiftDown(self.this)
+        return val
+    def LeftDown(self):
+        val = eventsc.wxMouseEvent_LeftDown(self.this)
+        return val
+    def MiddleDown(self):
+        val = eventsc.wxMouseEvent_MiddleDown(self.this)
+        return val
+    def RightDown(self):
+        val = eventsc.wxMouseEvent_RightDown(self.this)
+        return val
+    def LeftUp(self):
+        val = eventsc.wxMouseEvent_LeftUp(self.this)
+        return val
+    def MiddleUp(self):
+        val = eventsc.wxMouseEvent_MiddleUp(self.this)
+        return val
+    def RightUp(self):
+        val = eventsc.wxMouseEvent_RightUp(self.this)
+        return val
+    def LeftDClick(self):
+        val = eventsc.wxMouseEvent_LeftDClick(self.this)
+        return val
+    def MiddleDClick(self):
+        val = eventsc.wxMouseEvent_MiddleDClick(self.this)
+        return val
+    def RightDClick(self):
+        val = eventsc.wxMouseEvent_RightDClick(self.this)
+        return val
+    def LeftIsDown(self):
+        val = eventsc.wxMouseEvent_LeftIsDown(self.this)
+        return val
+    def MiddleIsDown(self):
+        val = eventsc.wxMouseEvent_MiddleIsDown(self.this)
+        return val
+    def RightIsDown(self):
+        val = eventsc.wxMouseEvent_RightIsDown(self.this)
+        return val
+    def Dragging(self):
+        val = eventsc.wxMouseEvent_Dragging(self.this)
+        return val
+    def Moving(self):
+        val = eventsc.wxMouseEvent_Moving(self.this)
+        return val
+    def Entering(self):
+        val = eventsc.wxMouseEvent_Entering(self.this)
+        return val
+    def Leaving(self):
+        val = eventsc.wxMouseEvent_Leaving(self.this)
+        return val
+    def Position(self):
+        val = eventsc.wxMouseEvent_Position(self.this)
+        return val
+    def GetPosition(self):
+        val = eventsc.wxMouseEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetLogicalPosition(self,arg0):
+        val = eventsc.wxMouseEvent_GetLogicalPosition(self.this,arg0.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetX(self):
+        val = eventsc.wxMouseEvent_GetX(self.this)
+        return val
+    def GetY(self):
+        val = eventsc.wxMouseEvent_GetY(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMouseEvent instance>"
+class wxMouseEvent(wxMouseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxKeyEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ControlDown(self):
+        val = eventsc.wxKeyEvent_ControlDown(self.this)
+        return val
+    def MetaDown(self):
+        val = eventsc.wxKeyEvent_MetaDown(self.this)
+        return val
+    def AltDown(self):
+        val = eventsc.wxKeyEvent_AltDown(self.this)
+        return val
+    def ShiftDown(self):
+        val = eventsc.wxKeyEvent_ShiftDown(self.this)
+        return val
+    def KeyCode(self):
+        val = eventsc.wxKeyEvent_KeyCode(self.this)
+        return val
+    def Position(self):
+        val = eventsc.wxKeyEvent_Position(self.this)
+        return val
+    def GetX(self):
+        val = eventsc.wxKeyEvent_GetX(self.this)
+        return val
+    def GetY(self):
+        val = eventsc.wxKeyEvent_GetY(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxKeyEvent instance>"
+class wxKeyEvent(wxKeyEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMoveEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxMoveEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxMoveEvent instance>"
+class wxMoveEvent(wxMoveEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxPaintEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPaintEvent instance>"
+class wxPaintEvent(wxPaintEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxEraseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetDC(self):
+        val = eventsc.wxEraseEvent_GetDC(self.this)
+        val = wxDCPtr(val)
+        return val
+    def __repr__(self):
+        return "<C wxEraseEvent instance>"
+class wxEraseEvent(wxEraseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxFocusEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxFocusEvent instance>"
+class wxFocusEvent(wxFocusEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxActivateEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetActive(self):
+        val = eventsc.wxActivateEvent_GetActive(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxActivateEvent instance>"
+class wxActivateEvent(wxActivateEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxInitDialogEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxInitDialogEvent instance>"
+class wxInitDialogEvent(wxInitDialogEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMenuEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetMenuId(self):
+        val = eventsc.wxMenuEvent_GetMenuId(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMenuEvent instance>"
+class wxMenuEvent(wxMenuEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxShowEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetShow(self,arg0):
+        val = eventsc.wxShowEvent_SetShow(self.this,arg0)
+        return val
+    def GetShow(self):
+        val = eventsc.wxShowEvent_GetShow(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxShowEvent instance>"
+class wxShowEvent(wxShowEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxIconizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxIconizeEvent instance>"
+class wxIconizeEvent(wxIconizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMaximizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMaximizeEvent instance>"
+class wxMaximizeEvent(wxMaximizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxJoystickEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxJoystickEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetZPosition(self):
+        val = eventsc.wxJoystickEvent_GetZPosition(self.this)
+        return val
+    def GetButtonState(self):
+        val = eventsc.wxJoystickEvent_GetButtonState(self.this)
+        return val
+    def GetButtonChange(self):
+        val = eventsc.wxJoystickEvent_GetButtonChange(self.this)
+        return val
+    def GetJoystick(self):
+        val = eventsc.wxJoystickEvent_GetJoystick(self.this)
+        return val
+    def SetJoystick(self,arg0):
+        val = eventsc.wxJoystickEvent_SetJoystick(self.this,arg0)
+        return val
+    def SetButtonState(self,arg0):
+        val = eventsc.wxJoystickEvent_SetButtonState(self.this,arg0)
+        return val
+    def SetButtonChange(self,arg0):
+        val = eventsc.wxJoystickEvent_SetButtonChange(self.this,arg0)
+        return val
+    def SetPosition(self,arg0):
+        val = eventsc.wxJoystickEvent_SetPosition(self.this,arg0.this)
+        return val
+    def SetZPosition(self,arg0):
+        val = eventsc.wxJoystickEvent_SetZPosition(self.this,arg0)
+        return val
+    def IsButton(self):
+        val = eventsc.wxJoystickEvent_IsButton(self.this)
+        return val
+    def IsMove(self):
+        val = eventsc.wxJoystickEvent_IsMove(self.this)
+        return val
+    def IsZMove(self):
+        val = eventsc.wxJoystickEvent_IsZMove(self.this)
+        return val
+    def ButtonDown(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonDown,(self.this,)+args)
+        return val
+    def ButtonUp(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonUp,(self.this,)+args)
+        return val
+    def ButtonIsDown(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxJoystickEvent instance>"
+class wxJoystickEvent(wxJoystickEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxDropFilesEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxDropFilesEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetNumberOfFiles(self):
+        val = eventsc.wxDropFilesEvent_GetNumberOfFiles(self.this)
+        return val
+    def GetFiles(self):
+        val = eventsc.wxDropFilesEvent_GetFiles(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDropFilesEvent instance>"
+class wxDropFilesEvent(wxDropFilesEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxIdleEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def RequestMore(self,*args):
+        val = apply(eventsc.wxIdleEvent_RequestMore,(self.this,)+args)
+        return val
+    def MoreRequested(self):
+        val = eventsc.wxIdleEvent_MoreRequested(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxIdleEvent instance>"
+class wxIdleEvent(wxIdleEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxUpdateUIEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetChecked(self):
+        val = eventsc.wxUpdateUIEvent_GetChecked(self.this)
+        return val
+    def GetEnabled(self):
+        val = eventsc.wxUpdateUIEvent_GetEnabled(self.this)
+        return val
+    def GetText(self):
+        val = eventsc.wxUpdateUIEvent_GetText(self.this)
+        return val
+    def GetSetText(self):
+        val = eventsc.wxUpdateUIEvent_GetSetText(self.this)
+        return val
+    def GetSetChecked(self):
+        val = eventsc.wxUpdateUIEvent_GetSetChecked(self.this)
+        return val
+    def GetSetEnabled(self):
+        val = eventsc.wxUpdateUIEvent_GetSetEnabled(self.this)
+        return val
+    def Check(self,arg0):
+        val = eventsc.wxUpdateUIEvent_Check(self.this,arg0)
+        return val
+    def Enable(self,arg0):
+        val = eventsc.wxUpdateUIEvent_Enable(self.this,arg0)
+        return val
+    def SetText(self,arg0):
+        val = eventsc.wxUpdateUIEvent_SetText(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxUpdateUIEvent instance>"
+class wxUpdateUIEvent(wxUpdateUIEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSysColourChangedEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxSysColourChangedEvent instance>"
+class wxSysColourChangedEvent(wxSysColourChangedEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/frames.py

@@ -0,0 +1,124 @@
+# This file was created automatically by SWIG.
+import framesc
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+
+from stattool import *
+
+from controls import *
+
+from events import *
+import wx
+class wxFramePtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Centre(self,*args):
+        val = apply(framesc.wxFrame_Centre,(self.this,)+args)
+        return val
+    def CreateStatusBar(self,*args):
+        val = apply(framesc.wxFrame_CreateStatusBar,(self.this,)+args)
+        val = wxStatusBarPtr(val)
+        return val
+    def CreateToolBar(self,*args):
+        val = apply(framesc.wxFrame_CreateToolBar,(self.this,)+args)
+        val = wxToolBarPtr(val)
+        return val
+    def GetMenuBar(self):
+        val = framesc.wxFrame_GetMenuBar(self.this)
+        val = wxMenuBarPtr(val)
+        return val
+    def GetStatusBar(self):
+        val = framesc.wxFrame_GetStatusBar(self.this)
+        val = wxStatusBarPtr(val)
+        return val
+    def GetTitle(self):
+        val = framesc.wxFrame_GetTitle(self.this)
+        return val
+    def GetToolBar(self):
+        val = framesc.wxFrame_GetToolBar(self.this)
+        val = wxToolBarPtr(val)
+        return val
+    def Iconize(self,arg0):
+        val = framesc.wxFrame_Iconize(self.this,arg0)
+        return val
+    def IsIconized(self):
+        val = framesc.wxFrame_IsIconized(self.this)
+        return val
+    def Maximize(self,arg0):
+        val = framesc.wxFrame_Maximize(self.this,arg0)
+        return val
+    def SetAcceleratorTable(self,arg0):
+        val = framesc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
+        return val
+    def SetIcon(self,arg0):
+        val = framesc.wxFrame_SetIcon(self.this,arg0.this)
+        return val
+    def SetMenuBar(self,arg0):
+        val = framesc.wxFrame_SetMenuBar(self.this,arg0.this)
+        return val
+    def SetStatusBar(self,arg0):
+        val = framesc.wxFrame_SetStatusBar(self.this,arg0.this)
+        return val
+    def SetStatusText(self,arg0,*args):
+        val = apply(framesc.wxFrame_SetStatusText,(self.this,arg0,)+args)
+        return val
+    def SetStatusWidths(self,arg0,*args):
+        val = apply(framesc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
+        return val
+    def SetTitle(self,arg0):
+        val = framesc.wxFrame_SetTitle(self.this,arg0)
+        return val
+    def SetToolBar(self,arg0):
+        val = framesc.wxFrame_SetToolBar(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxFrame instance>"
+class wxFrame(wxFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(framesc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+class wxMiniFramePtr(wxFramePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMiniFrame instance>"
+class wxMiniFrame(wxMiniFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(framesc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/gdi.py

@@ -0,0 +1,758 @@
+# This file was created automatically by SWIG.
+import gdic
+
+from misc import *
+class wxBitmapPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxBitmap(self.this)
+    def GetDepth(self):
+        val = gdic.wxBitmap_GetDepth(self.this)
+        return val
+    def GetHeight(self):
+        val = gdic.wxBitmap_GetHeight(self.this)
+        return val
+    def GetPalette(self):
+        val = gdic.wxBitmap_GetPalette(self.this)
+        val = wxPalettePtr(val)
+        return val
+    def GetMask(self):
+        val = gdic.wxBitmap_GetMask(self.this)
+        val = wxMaskPtr(val)
+        return val
+    def GetWidth(self):
+        val = gdic.wxBitmap_GetWidth(self.this)
+        return val
+    def LoadFile(self,arg0,arg1):
+        val = gdic.wxBitmap_LoadFile(self.this,arg0,arg1)
+        return val
+    def Ok(self):
+        val = gdic.wxBitmap_Ok(self.this)
+        return val
+    def SaveFile(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxBitmap_SaveFile,(self.this,arg0,arg1,)+args)
+        return val
+    def SetDepth(self,arg0):
+        val = gdic.wxBitmap_SetDepth(self.this,arg0)
+        return val
+    def SetHeight(self,arg0):
+        val = gdic.wxBitmap_SetHeight(self.this,arg0)
+        return val
+    def SetMask(self,arg0):
+        val = gdic.wxBitmap_SetMask(self.this,arg0.this)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxBitmap_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxBitmap instance>"
+class wxBitmap(wxBitmapPtr):
+    def __init__(self,arg0,arg1) :
+        self.this = gdic.new_wxBitmap(arg0,arg1)
+        self.thisown = 1
+
+
+
+
+class wxMaskPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxMask(self.this)
+    def __repr__(self):
+        return "<C wxMask instance>"
+class wxMask(wxMaskPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxMask(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxIconPtr(wxBitmapPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxIcon(self.this)
+    def GetDepth(self):
+        val = gdic.wxIcon_GetDepth(self.this)
+        return val
+    def GetHeight(self):
+        val = gdic.wxIcon_GetHeight(self.this)
+        return val
+    def GetWidth(self):
+        val = gdic.wxIcon_GetWidth(self.this)
+        return val
+    def LoadFile(self,arg0,arg1):
+        val = gdic.wxIcon_LoadFile(self.this,arg0,arg1)
+        return val
+    def Ok(self):
+        val = gdic.wxIcon_Ok(self.this)
+        return val
+    def SetDepth(self,arg0):
+        val = gdic.wxIcon_SetDepth(self.this,arg0)
+        return val
+    def SetHeight(self,arg0):
+        val = gdic.wxIcon_SetHeight(self.this,arg0)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxIcon_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxIcon instance>"
+class wxIcon(wxIconPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCursorPtr(wxBitmapPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxCursor(self.this)
+    def Ok(self):
+        val = gdic.wxCursor_Ok(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCursor instance>"
+class wxCursor(wxCursorPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxFontPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFaceName(self):
+        val = gdic.wxFont_GetFaceName(self.this)
+        return val
+    def GetFamily(self):
+        val = gdic.wxFont_GetFamily(self.this)
+        return val
+    def GetPointSize(self):
+        val = gdic.wxFont_GetPointSize(self.this)
+        return val
+    def GetStyle(self):
+        val = gdic.wxFont_GetStyle(self.this)
+        return val
+    def GetUnderlined(self):
+        val = gdic.wxFont_GetUnderlined(self.this)
+        return val
+    def GetWeight(self):
+        val = gdic.wxFont_GetWeight(self.this)
+        return val
+    def SetFaceName(self,arg0):
+        val = gdic.wxFont_SetFaceName(self.this,arg0)
+        return val
+    def SetFamily(self,arg0):
+        val = gdic.wxFont_SetFamily(self.this,arg0)
+        return val
+    def SetPointSize(self,arg0):
+        val = gdic.wxFont_SetPointSize(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxFont_SetStyle(self.this,arg0)
+        return val
+    def SetUnderlined(self,arg0):
+        val = gdic.wxFont_SetUnderlined(self.this,arg0)
+        return val
+    def SetWeight(self,arg0):
+        val = gdic.wxFont_SetWeight(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxFont instance>"
+class wxFont(wxFontPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,*args) :
+        self.this = apply(gdic.new_wxFont,(arg0,arg1,arg2,arg3,)+args)
+        self.thisown = 1
+
+
+
+
+class wxColourPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxColour(self.this)
+    def Red(self):
+        val = gdic.wxColour_Red(self.this)
+        return val
+    def Green(self):
+        val = gdic.wxColour_Green(self.this)
+        return val
+    def Blue(self):
+        val = gdic.wxColour_Blue(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxColour_Ok(self.this)
+        return val
+    def Set(self,arg0,arg1,arg2):
+        val = gdic.wxColour_Set(self.this,arg0,arg1,arg2)
+        return val
+    def Get(self):
+        val = gdic.wxColour_Get(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxColour instance>"
+class wxColour(wxColourPtr):
+    def __init__(self,*args) :
+        self.this = apply(gdic.new_wxColour,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPenPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetCap(self):
+        val = gdic.wxPen_GetCap(self.this)
+        return val
+    def GetColour(self):
+        val = gdic.wxPen_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetJoin(self):
+        val = gdic.wxPen_GetJoin(self.this)
+        return val
+    def GetStyle(self):
+        val = gdic.wxPen_GetStyle(self.this)
+        return val
+    def GetWidth(self):
+        val = gdic.wxPen_GetWidth(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxPen_Ok(self.this)
+        return val
+    def SetCap(self,arg0):
+        val = gdic.wxPen_SetCap(self.this,arg0)
+        return val
+    def SetColour(self,arg0):
+        val = gdic.wxPen_SetColour(self.this,arg0.this)
+        return val
+    def SetJoin(self,arg0):
+        val = gdic.wxPen_SetJoin(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxPen_SetStyle(self.this,arg0)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxPen_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPen instance>"
+class wxPen(wxPenPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(gdic.new_wxPen,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxBrushPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetColour(self):
+        val = gdic.wxBrush_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetStipple(self):
+        val = gdic.wxBrush_GetStipple(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetStyle(self):
+        val = gdic.wxBrush_GetStyle(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxBrush_Ok(self.this)
+        return val
+    def SetColour(self,arg0):
+        val = gdic.wxBrush_SetColour(self.this,arg0.this)
+        return val
+    def SetStipple(self,arg0):
+        val = gdic.wxBrush_SetStipple(self.this,arg0.this)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxBrush_SetStyle(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxBrush instance>"
+class wxBrush(wxBrushPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(gdic.new_wxBrush,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxDCPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxDC(self.this)
+    def BeginDrawing(self):
+        val = gdic.wxDC_BeginDrawing(self.this)
+        return val
+    def Blit(self,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7):
+        val = gdic.wxDC_Blit(self.this,arg0,arg1,arg2,arg3,arg4.this,arg5,arg6,arg7)
+        return val
+    def Clear(self):
+        val = gdic.wxDC_Clear(self.this)
+        return val
+    def CrossHair(self,arg0,arg1):
+        val = gdic.wxDC_CrossHair(self.this,arg0,arg1)
+        return val
+    def DestroyClippingRegion(self):
+        val = gdic.wxDC_DestroyClippingRegion(self.this)
+        return val
+    def DeviceToLogicalX(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalX(self.this,arg0)
+        return val
+    def DeviceToLogicalXRel(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalXRel(self.this,arg0)
+        return val
+    def DeviceToLogicalY(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalY(self.this,arg0)
+        return val
+    def DeviceToLogicalYRel(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalYRel(self.this,arg0)
+        return val
+    def DrawArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
+        val = gdic.wxDC_DrawArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
+        return val
+    def DrawEllipse(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawEllipse(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawEllipticArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
+        val = gdic.wxDC_DrawEllipticArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
+        return val
+    def DrawIcon(self,arg0,arg1,arg2):
+        val = gdic.wxDC_DrawIcon(self.this,arg0.this,arg1,arg2)
+        return val
+    def DrawLine(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawLine(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawLines(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawLines,(self.this,arg0,)+args)
+        return val
+    def DrawPolygon(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawPolygon,(self.this,arg0,)+args)
+        return val
+    def DrawPoint(self,arg0,arg1):
+        val = gdic.wxDC_DrawPoint(self.this,arg0,arg1)
+        return val
+    def DrawRectangle(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawRectangle(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawRoundedRectangle(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(gdic.wxDC_DrawRoundedRectangle,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def DrawSpline(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawSpline,(self.this,arg0,)+args)
+        return val
+    def DrawText(self,arg0,arg1,arg2):
+        val = gdic.wxDC_DrawText(self.this,arg0,arg1,arg2)
+        return val
+    def EndDoc(self):
+        val = gdic.wxDC_EndDoc(self.this)
+        return val
+    def EndDrawing(self):
+        val = gdic.wxDC_EndDrawing(self.this)
+        return val
+    def EndPage(self):
+        val = gdic.wxDC_EndPage(self.this)
+        return val
+    def FloodFill(self,arg0,arg1,arg2,*args):
+        val = apply(gdic.wxDC_FloodFill,(self.this,arg0,arg1,arg2.this,)+args)
+        return val
+    def GetBackground(self):
+        val = gdic.wxDC_GetBackground(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetBrush(self):
+        val = gdic.wxDC_GetBrush(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetCharHeight(self):
+        val = gdic.wxDC_GetCharHeight(self.this)
+        return val
+    def GetCharWidth(self):
+        val = gdic.wxDC_GetCharWidth(self.this)
+        return val
+    def GetClippingBox(self):
+        val = gdic.wxDC_GetClippingBox(self.this)
+        return val
+    def GetFont(self):
+        val = gdic.wxDC_GetFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetLogicalFunction(self):
+        val = gdic.wxDC_GetLogicalFunction(self.this)
+        return val
+    def GetMapMode(self):
+        val = gdic.wxDC_GetMapMode(self.this)
+        return val
+    def GetOptimization(self):
+        val = gdic.wxDC_GetOptimization(self.this)
+        return val
+    def GetPen(self):
+        val = gdic.wxDC_GetPen(self.this)
+        val = wxPenPtr(val)
+        return val
+    def GetPixel(self,arg0,arg1):
+        val = gdic.wxDC_GetPixel(self.this,arg0,arg1)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def GetSize(self):
+        val = gdic.wxDC_GetSize(self.this)
+        return val
+    def GetTextBackground(self):
+        val = gdic.wxDC_GetTextBackground(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetTextExtent(self,arg0):
+        val = gdic.wxDC_GetTextExtent(self.this,arg0)
+        return val
+    def GetTextForeground(self):
+        val = gdic.wxDC_GetTextForeground(self.this)
+        val = wxColourPtr(val)
+        return val
+    def LogicalToDeviceX(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceX(self.this,arg0)
+        return val
+    def LogicalToDeviceXRel(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceXRel(self.this,arg0)
+        return val
+    def LogicalToDeviceY(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceY(self.this,arg0)
+        return val
+    def LogicalToDeviceYRel(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceYRel(self.this,arg0)
+        return val
+    def MaxX(self):
+        val = gdic.wxDC_MaxX(self.this)
+        return val
+    def MaxY(self):
+        val = gdic.wxDC_MaxY(self.this)
+        return val
+    def MinX(self):
+        val = gdic.wxDC_MinX(self.this)
+        return val
+    def MinY(self):
+        val = gdic.wxDC_MinY(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxDC_Ok(self.this)
+        return val
+    def SetDeviceOrigin(self,arg0,arg1):
+        val = gdic.wxDC_SetDeviceOrigin(self.this,arg0,arg1)
+        return val
+    def SetBackground(self,arg0):
+        val = gdic.wxDC_SetBackground(self.this,arg0.this)
+        return val
+    def SetBackgroundMode(self,arg0):
+        val = gdic.wxDC_SetBackgroundMode(self.this,arg0)
+        return val
+    def SetClippingRegion(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_SetClippingRegion(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def SetPalette(self,arg0):
+        val = gdic.wxDC_SetPalette(self.this,arg0.this)
+        return val
+    def SetBrush(self,arg0):
+        val = gdic.wxDC_SetBrush(self.this,arg0.this)
+        return val
+    def SetFont(self,arg0):
+        val = gdic.wxDC_SetFont(self.this,arg0.this)
+        return val
+    def SetLogicalFunction(self,arg0):
+        val = gdic.wxDC_SetLogicalFunction(self.this,arg0)
+        return val
+    def SetMapMode(self,arg0):
+        val = gdic.wxDC_SetMapMode(self.this,arg0)
+        return val
+    def SetOptimization(self,arg0):
+        val = gdic.wxDC_SetOptimization(self.this,arg0)
+        return val
+    def SetPen(self,arg0):
+        val = gdic.wxDC_SetPen(self.this,arg0.this)
+        return val
+    def SetTextBackground(self,arg0):
+        val = gdic.wxDC_SetTextBackground(self.this,arg0.this)
+        return val
+    def SetTextForeground(self,arg0):
+        val = gdic.wxDC_SetTextForeground(self.this,arg0.this)
+        return val
+    def SetUserScale(self,arg0,arg1):
+        val = gdic.wxDC_SetUserScale(self.this,arg0,arg1)
+        return val
+    def StartDoc(self,arg0):
+        val = gdic.wxDC_StartDoc(self.this,arg0)
+        return val
+    def StartPage(self):
+        val = gdic.wxDC_StartPage(self.this)
+        return val
+    def DrawBitmap(self,arg0,arg1,arg2,*args):
+        val = apply(gdic.wxDC_DrawBitmap,(self.this,arg0.this,arg1,arg2,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxDC instance>"
+class wxDC(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMemoryDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SelectObject(self,arg0):
+        val = gdic.wxMemoryDC_SelectObject(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxMemoryDC instance>"
+class wxMemoryDC(wxMemoryDCPtr):
+    def __init__(self) :
+        self.this = gdic.new_wxMemoryDC()
+        self.thisown = 1
+
+
+
+
+class wxScreenDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def StartDrawingOnTop(self,arg0):
+        val = gdic.wxScreenDC_StartDrawingOnTop(self.this,arg0.this)
+        return val
+    def StartDrawingOnTopRect(self,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxScreenDC_StartDrawingOnTopRect,(self.this,)+args)
+        return val
+    def EndDrawingOnTop(self):
+        val = gdic.wxScreenDC_EndDrawingOnTop(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScreenDC instance>"
+class wxScreenDC(wxScreenDCPtr):
+    def __init__(self) :
+        self.this = gdic.new_wxScreenDC()
+        self.thisown = 1
+
+
+
+
+class wxClientDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxClientDC instance>"
+class wxClientDC(wxClientDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxClientDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxPaintDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPaintDC instance>"
+class wxPaintDC(wxPaintDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxPaintDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxWindowDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxWindowDC instance>"
+class wxWindowDC(wxWindowDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxWindowDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxPostScriptDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPostScriptDC instance>"
+class wxPostScriptDC(wxPostScriptDCPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(gdic.new_wxPostScriptDC,(arg0,)+args)
+        self.thisown = 1
+
+
+
+
+class wxPalettePtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxPalette(self.this)
+    def GetPixel(self,arg0,arg1,arg2):
+        val = gdic.wxPalette_GetPixel(self.this,arg0,arg1,arg2)
+        return val
+    def GetRGB(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxPalette_GetRGB(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def Ok(self):
+        val = gdic.wxPalette_Ok(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPalette instance>"
+class wxPalette(wxPalettePtr):
+    def __init__(self,arg0,arg1,arg2) :
+        self.this = gdic.new_wxPalette(arg0,arg1,arg2)
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+def wxEmptyBitmap(arg0,arg1,*args):
+    val = apply(gdic.wxEmptyBitmap,(arg0,arg1,)+args)
+    val = wxBitmapPtr(val)
+    val.thisown = 1
+    return val
+
+def wxNoRefBitmap(arg0,arg1):
+    val = gdic.wxNoRefBitmap(arg0,arg1)
+    val = wxBitmapPtr(val)
+    return val
+
+def wxMaskColour(arg0,arg1):
+    val = gdic.wxMaskColour(arg0.this,arg1.this)
+    val = wxMaskPtr(val)
+    val.thisown = 1
+    return val
+
+def wxStockCursor(arg0):
+    val = gdic.wxStockCursor(arg0)
+    val = wxCursorPtr(val)
+    val.thisown = 1
+    return val
+
+def wxNamedColour(arg0):
+    val = gdic.wxNamedColour(arg0)
+    val = wxColourPtr(val)
+    val.thisown = 1
+    return val
+
+def wxMemoryDCFromDC(arg0):
+    val = gdic.wxMemoryDCFromDC(arg0.this)
+    val = wxMemoryDCPtr(val)
+    val.thisown = 1
+    return val
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+cvar = gdic.cvar
+wxNORMAL_FONT = wxFontPtr(gdic.cvar.wxNORMAL_FONT)
+wxSMALL_FONT = wxFontPtr(gdic.cvar.wxSMALL_FONT)
+wxITALIC_FONT = wxFontPtr(gdic.cvar.wxITALIC_FONT)
+wxSWISS_FONT = wxFontPtr(gdic.cvar.wxSWISS_FONT)
+wxRED_PEN = wxPenPtr(gdic.cvar.wxRED_PEN)
+wxCYAN_PEN = wxPenPtr(gdic.cvar.wxCYAN_PEN)
+wxGREEN_PEN = wxPenPtr(gdic.cvar.wxGREEN_PEN)
+wxBLACK_PEN = wxPenPtr(gdic.cvar.wxBLACK_PEN)
+wxWHITE_PEN = wxPenPtr(gdic.cvar.wxWHITE_PEN)
+wxTRANSPARENT_PEN = wxPenPtr(gdic.cvar.wxTRANSPARENT_PEN)
+wxBLACK_DASHED_PEN = wxPenPtr(gdic.cvar.wxBLACK_DASHED_PEN)
+wxGREY_PEN = wxPenPtr(gdic.cvar.wxGREY_PEN)
+wxMEDIUM_GREY_PEN = wxPenPtr(gdic.cvar.wxMEDIUM_GREY_PEN)
+wxLIGHT_GREY_PEN = wxPenPtr(gdic.cvar.wxLIGHT_GREY_PEN)
+wxBLUE_BRUSH = wxBrushPtr(gdic.cvar.wxBLUE_BRUSH)
+wxGREEN_BRUSH = wxBrushPtr(gdic.cvar.wxGREEN_BRUSH)
+wxWHITE_BRUSH = wxBrushPtr(gdic.cvar.wxWHITE_BRUSH)
+wxBLACK_BRUSH = wxBrushPtr(gdic.cvar.wxBLACK_BRUSH)
+wxTRANSPARENT_BRUSH = wxBrushPtr(gdic.cvar.wxTRANSPARENT_BRUSH)
+wxCYAN_BRUSH = wxBrushPtr(gdic.cvar.wxCYAN_BRUSH)
+wxRED_BRUSH = wxBrushPtr(gdic.cvar.wxRED_BRUSH)
+wxGREY_BRUSH = wxBrushPtr(gdic.cvar.wxGREY_BRUSH)
+wxMEDIUM_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxMEDIUM_GREY_BRUSH)
+wxLIGHT_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxLIGHT_GREY_BRUSH)
+wxBLACK = wxColourPtr(gdic.cvar.wxBLACK)
+wxWHITE = wxColourPtr(gdic.cvar.wxWHITE)
+wxRED = wxColourPtr(gdic.cvar.wxRED)
+wxBLUE = wxColourPtr(gdic.cvar.wxBLUE)
+wxGREEN = wxColourPtr(gdic.cvar.wxGREEN)
+wxCYAN = wxColourPtr(gdic.cvar.wxCYAN)
+wxLIGHT_GREY = wxColourPtr(gdic.cvar.wxLIGHT_GREY)
+wxSTANDARD_CURSOR = wxCursorPtr(gdic.cvar.wxSTANDARD_CURSOR)
+wxHOURGLASS_CURSOR = wxCursorPtr(gdic.cvar.wxHOURGLASS_CURSOR)
+wxCROSS_CURSOR = wxCursorPtr(gdic.cvar.wxCROSS_CURSOR)
+wxNullBitmap = wxBitmapPtr(gdic.cvar.wxNullBitmap)
+wxNullIcon = wxIconPtr(gdic.cvar.wxNullIcon)
+wxNullCursor = wxCursorPtr(gdic.cvar.wxNullCursor)
+wxNullPen = wxPenPtr(gdic.cvar.wxNullPen)
+wxNullBrush = wxBrushPtr(gdic.cvar.wxNullBrush)
+wxNullFont = wxFontPtr(gdic.cvar.wxNullFont)
+wxNullColour = wxColourPtr(gdic.cvar.wxNullColour)

utils/wxPython/src/gtk/mdi.cpp

@@ -0,0 +1,964 @@
+/*
+ * FILE : gtk/mdi.cpp
+ * 
+ * This file was automatically generated by :
+ * Simplified Wrapper and Interface Generator (SWIG)
+ * Version 1.1 (Patch 5)
+ * 
+ * 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,b) __declspec(dllexport) a b
+#   else
+#	if defined(__BORLANDC__)
+#	    define SWIGEXPORT(a,b) a _export b
+#	else
+#	    define SWIGEXPORT(a,b) a b
+#	endif
+#   endif
+#else
+#   define SWIGEXPORT(a,b) a b
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "Python.h"
+extern void SWIG_MakePtr(char *, void *, char *);
+extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
+extern char *SWIG_GetPtr(char *, void **, char *);
+extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
+extern PyObject *SWIG_newvarlink(void);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_init    initmdic
+
+#define SWIG_name    "mdic"
+
+#include "helpers.h"
+
+static PyObject* l_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 (!PyList_Check(target)) {
+            o2 = target;
+            target = PyList_New(0);
+            PyList_Append(target, o2);
+	    Py_XDECREF(o2);
+        }
+        PyList_Append(target,o);
+	Py_XDECREF(o);
+    }
+    return target;
+}
+
+static PyObject* t_output_helper(PyObject* target, PyObject* o) {
+    PyObject*   o2;
+    PyObject*   o3;
+
+    if (!target) {                   
+        target = o;
+    } else if (target == Py_None) {  
+        Py_DECREF(Py_None);
+        target = o;
+    } else {                         
+        if (!PyTuple_Check(target)) {
+            o2 = target;
+            target = PyTuple_New(1);
+            PyTuple_SetItem(target, 0, o2);
+        }
+        o3 = PyTuple_New(1);            
+        PyTuple_SetItem(o3, 0, o);      
+
+        o2 = target;
+        target = PySequence_Concat(o2, o3); 
+        Py_DECREF(o2);                      
+        Py_DECREF(o3);
+    }
+    return target;
+}
+
+
+extern byte* byte_LIST_helper(PyObject* source);
+extern int* int_LIST_helper(PyObject* source);
+extern long* long_LIST_helper(PyObject* source);
+extern char** string_LIST_helper(PyObject* source);
+extern wxPoint* wxPoint_LIST_helper(PyObject* source);
+extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
+extern wxString* wxString_LIST_helper(PyObject* source);
+extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+
+
+static char* wxStringErrorMsg = "string type is required for parameter";
+static void *SwigwxMDIParentFrameTowxFrame(void *ptr) {
+    wxMDIParentFrame *src;
+    wxFrame *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxFrame *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIParentFrameTowxWindow(void *ptr) {
+    wxMDIParentFrame *src;
+    wxWindow *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIParentFrameTowxEvtHandler(void *ptr) {
+    wxMDIParentFrame *src;
+    wxEvtHandler *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
+static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _result;
+    wxWindow * _arg0;
+    wxWindowID  _arg1;
+    wxString * _arg2;
+    wxPoint * _arg3 = &wxPyDefaultPosition;
+    wxSize * _arg4 = &wxPyDefaultSize;
+    long  _arg5 = (wxDEFAULT_FRAME_STYLE)|(wxVSCROLL)|(wxHSCROLL);
+    char * _arg6 = "frame";
+    char * _argc0 = 0;
+    PyObject * _obj2 = 0;
+    char * _argc3 = 0;
+    char * _argc4 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIParentFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIParentFrame. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+{
+    if (!PyString_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+        return NULL;
+    }
+    _arg2 = new wxString(PyString_AsString(_obj2));
+}
+    if (_argc3) {
+        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIParentFrame. Expected _wxPoint_p.");
+        return NULL;
+        }
+    }
+    if (_argc4) {
+        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIParentFrame. Expected _wxSize_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+{
+    if (_obj2)
+        delete _arg2;
+}
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ActivateNext(_swigobj)  (_swigobj->ActivateNext())
+static PyObject *_wrap_wxMDIParentFrame_ActivateNext(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivateNext",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivateNext. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ActivateNext(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ActivatePrevious(_swigobj)  (_swigobj->ActivatePrevious())
+static PyObject *_wrap_wxMDIParentFrame_ActivatePrevious(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivatePrevious",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivatePrevious. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ActivatePrevious(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ArrangeIcons(_swigobj)  (_swigobj->ArrangeIcons())
+static PyObject *_wrap_wxMDIParentFrame_ArrangeIcons(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ArrangeIcons",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ArrangeIcons. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ArrangeIcons(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_Cascade(_swigobj)  (_swigobj->Cascade())
+static PyObject *_wrap_wxMDIParentFrame_Cascade(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Cascade",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Cascade. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_Cascade(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIParentFrame_GetClientSize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    char * _argc0 = 0;
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientSize",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientSize. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_GetClientSize(_arg0,_arg1,_arg2);
+    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 wxMDIParentFrame_GetActiveChild(_swigobj)  (_swigobj->GetActiveChild())
+static PyObject *_wrap_wxMDIParentFrame_GetActiveChild(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetActiveChild",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetActiveChild. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetClientWindow(_swigobj)  (_swigobj->GetClientWindow())
+static PyObject *_wrap_wxMDIParentFrame_GetClientWindow(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIClientWindow * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientWindow",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientWindow. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetToolBar(_swigobj)  (_swigobj->GetToolBar())
+static PyObject *_wrap_wxMDIParentFrame_GetToolBar(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxWindow * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetToolBar",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetToolBar. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_Tile(_swigobj)  (_swigobj->Tile())
+static PyObject *_wrap_wxMDIParentFrame_Tile(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Tile",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Tile. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_Tile(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+static void *SwigwxMDIChildFrameTowxFrame(void *ptr) {
+    wxMDIChildFrame *src;
+    wxFrame *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxFrame *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIChildFrameTowxWindow(void *ptr) {
+    wxMDIChildFrame *src;
+    wxWindow *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIChildFrameTowxEvtHandler(void *ptr) {
+    wxMDIChildFrame *src;
+    wxEvtHandler *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
+static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _result;
+    wxMDIParentFrame * _arg0;
+    wxWindowID  _arg1;
+    wxString * _arg2;
+    wxPoint * _arg3 = &wxPyDefaultPosition;
+    wxSize * _arg4 = &wxPyDefaultSize;
+    long  _arg5 = (wxDEFAULT_FRAME_STYLE);
+    char * _arg6 = "frame";
+    char * _argc0 = 0;
+    PyObject * _obj2 = 0;
+    char * _argc3 = 0;
+    char * _argc4 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIChildFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIChildFrame. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+{
+    if (!PyString_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+        return NULL;
+    }
+    _arg2 = new wxString(PyString_AsString(_obj2));
+}
+    if (_argc3) {
+        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIChildFrame. Expected _wxPoint_p.");
+        return NULL;
+        }
+    }
+    if (_argc4) {
+        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIChildFrame. Expected _wxSize_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+{
+    if (_obj2)
+        delete _arg2;
+}
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Activate(_swigobj)  (_swigobj->Activate())
+static PyObject *_wrap_wxMDIChildFrame_Activate(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Activate",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Activate. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Activate(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Maximize(_swigobj)  (_swigobj->Maximize())
+static PyObject *_wrap_wxMDIChildFrame_Maximize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Maximize",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Maximize. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Maximize(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Restore(_swigobj)  (_swigobj->Restore())
+static PyObject *_wrap_wxMDIChildFrame_Restore(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Restore",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Restore. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Restore(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_SetMenuBar(_swigobj,_swigarg0)  (_swigobj->SetMenuBar(_swigarg0))
+static PyObject *_wrap_wxMDIChildFrame_SetMenuBar(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    wxMenuBar * _arg1;
+    char * _argc0 = 0;
+    char * _argc1 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"ss:wxMDIChildFrame_SetMenuBar",&_argc0,&_argc1)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetMenuBar. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    if (_argc1) {
+        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxMenuBar_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIChildFrame_SetMenuBar. Expected _wxMenuBar_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_SetMenuBar(_arg0,_arg1);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_SetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIChildFrame_SetClientSize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    int  _arg1;
+    int  _arg2;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"sii:wxMDIChildFrame_SetClientSize",&_argc0,&_arg1,&_arg2)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetClientSize. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_SetClientSize(_arg0,_arg1,_arg2);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_GetPosition(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetPosition(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIChildFrame_GetPosition(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    char * _argc0 = 0;
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_GetPosition",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_GetPosition. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_GetPosition(_arg0,_arg1,_arg2);
+    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;
+}
+
+static void *SwigwxMDIClientWindowTowxWindow(void *ptr) {
+    wxMDIClientWindow *src;
+    wxWindow *dest;
+    src = (wxMDIClientWindow *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIClientWindowTowxEvtHandler(void *ptr) {
+    wxMDIClientWindow *src;
+    wxEvtHandler *dest;
+    src = (wxMDIClientWindow *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIClientWindow(_swigarg0,_swigarg1) (new wxMDIClientWindow(_swigarg0,_swigarg1))
+static PyObject *_wrap_new_wxMDIClientWindow(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIClientWindow * _result;
+    wxMDIParentFrame * _arg0;
+    long  _arg1 = 0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s|l:new_wxMDIClientWindow",&_argc0,&_arg1)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIClientWindow. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+static PyMethodDef mdicMethods[] = {
+	 { "new_wxMDIClientWindow", _wrap_new_wxMDIClientWindow, 1 },
+	 { "wxMDIChildFrame_GetPosition", _wrap_wxMDIChildFrame_GetPosition, 1 },
+	 { "wxMDIChildFrame_SetClientSize", _wrap_wxMDIChildFrame_SetClientSize, 1 },
+	 { "wxMDIChildFrame_SetMenuBar", _wrap_wxMDIChildFrame_SetMenuBar, 1 },
+	 { "wxMDIChildFrame_Restore", _wrap_wxMDIChildFrame_Restore, 1 },
+	 { "wxMDIChildFrame_Maximize", _wrap_wxMDIChildFrame_Maximize, 1 },
+	 { "wxMDIChildFrame_Activate", _wrap_wxMDIChildFrame_Activate, 1 },
+	 { "new_wxMDIChildFrame", _wrap_new_wxMDIChildFrame, 1 },
+	 { "wxMDIParentFrame_Tile", _wrap_wxMDIParentFrame_Tile, 1 },
+	 { "wxMDIParentFrame_GetToolBar", _wrap_wxMDIParentFrame_GetToolBar, 1 },
+	 { "wxMDIParentFrame_GetClientWindow", _wrap_wxMDIParentFrame_GetClientWindow, 1 },
+	 { "wxMDIParentFrame_GetActiveChild", _wrap_wxMDIParentFrame_GetActiveChild, 1 },
+	 { "wxMDIParentFrame_GetClientSize", _wrap_wxMDIParentFrame_GetClientSize, 1 },
+	 { "wxMDIParentFrame_Cascade", _wrap_wxMDIParentFrame_Cascade, 1 },
+	 { "wxMDIParentFrame_ArrangeIcons", _wrap_wxMDIParentFrame_ArrangeIcons, 1 },
+	 { "wxMDIParentFrame_ActivatePrevious", _wrap_wxMDIParentFrame_ActivatePrevious, 1 },
+	 { "wxMDIParentFrame_ActivateNext", _wrap_wxMDIParentFrame_ActivateNext, 1 },
+	 { "new_wxMDIParentFrame", _wrap_new_wxMDIParentFrame, 1 },
+	 { NULL, NULL }
+};
+static PyObject *SWIG_globals;
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT(void,initmdic)() {
+	 PyObject *m, *d;
+	 SWIG_globals = SWIG_newvarlink();
+	 m = Py_InitModule("mdic", mdicMethods);
+	 d = PyModule_GetDict(m);
+/*
+ * These are the pointer type-equivalency mappings. 
+ * (Used by the SWIG pointer type-checker).
+ */
+	 SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
+	 SWIG_RegisterMapping("_wxEvent","_class_wxEvent",0);
+	 SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
+	 SWIG_RegisterMapping("_signed_long","_long",0);
+	 SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
+	 SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
+	 SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
+	 SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
+	 SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
+	 SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
+	 SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
+	 SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
+	 SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
+	 SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
+	 SWIG_RegisterMapping("_byte","_unsigned_char",0);
+	 SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0);
+	 SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
+	 SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
+	 SWIG_RegisterMapping("_long","_wxDash",0);
+	 SWIG_RegisterMapping("_long","_unsigned_long",0);
+	 SWIG_RegisterMapping("_long","_signed_long",0);
+	 SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0);
+	 SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0);
+	 SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
+	 SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
+	 SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
+	 SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
+	 SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
+	 SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
+	 SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0);
+	 SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0);
+	 SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0);
+	 SWIG_RegisterMapping("_class_wxPostScriptDC","_wxPostScriptDC",0);
+	 SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
+	 SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0);
+	 SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0);
+	 SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0);
+	 SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
+	 SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0);
+	 SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
+	 SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
+	 SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
+	 SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
+	 SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
+	 SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
+	 SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
+	 SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
+	 SWIG_RegisterMapping("_uint","_unsigned_int",0);
+	 SWIG_RegisterMapping("_uint","_int",0);
+	 SWIG_RegisterMapping("_uint","_wxWindowID",0);
+	 SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
+	 SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
+	 SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
+	 SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
+	 SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0);
+	 SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
+	 SWIG_RegisterMapping("_class_wxButton","_wxButton",0);
+	 SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0);
+	 SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
+	 SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
+	 SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
+	 SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
+	 SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
+	 SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
+	 SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
+	 SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
+	 SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
+	 SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
+	 SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
+	 SWIG_RegisterMapping("_EBool","_signed_int",0);
+	 SWIG_RegisterMapping("_EBool","_int",0);
+	 SWIG_RegisterMapping("_EBool","_wxWindowID",0);
+	 SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
+	 SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0);
+	 SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
+	 SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
+	 SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
+	 SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
+	 SWIG_RegisterMapping("_unsigned_long","_long",0);
+	 SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
+	 SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
+	 SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0);
+	 SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
+	 SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0);
+	 SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxSpinButton","_wxSpinButton",0);
+	 SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
+	 SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
+	 SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
+	 SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
+	 SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
+	 SWIG_RegisterMapping("_signed_int","_EBool",0);
+	 SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_signed_int","_int",0);
+	 SWIG_RegisterMapping("_class_wxTextCtrl","_wxTextCtrl",0);
+	 SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
+	 SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
+	 SWIG_RegisterMapping("_class_wxMoveEvent","_wxMoveEvent",0);
+	 SWIG_RegisterMapping("_wxListBox","_class_wxListBox",0);
+	 SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
+	 SWIG_RegisterMapping("_class_wxMDIChildFrame","_wxMDIChildFrame",0);
+	 SWIG_RegisterMapping("_WXTYPE","_short",0);
+	 SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
+	 SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
+	 SWIG_RegisterMapping("_class_wxMDIClientWindow","_wxMDIClientWindow",0);
+	 SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
+	 SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_unsigned_short","_short",0);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
+	 SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0);
+	 SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
+	 SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0);
+	 SWIG_RegisterMapping("_class_wxMenuEvent","_wxMenuEvent",0);
+	 SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
+	 SWIG_RegisterMapping("_wxMouseEvent","_class_wxMouseEvent",0);
+	 SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
+	 SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
+	 SWIG_RegisterMapping("_class_wxRadioBox","_wxRadioBox",0);
+	 SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_signed_short","_short",0);
+	 SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
+	 SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
+	 SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
+	 SWIG_RegisterMapping("_class_wxFocusEvent","_wxFocusEvent",0);
+	 SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0);
+	 SWIG_RegisterMapping("_wxStatusBar","_class_wxStatusBar",0);
+	 SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0);
+	 SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
+	 SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
+	 SWIG_RegisterMapping("_wxPostScriptDC","_class_wxPostScriptDC",0);
+	 SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
+	 SWIG_RegisterMapping("_unsigned_char","_byte",0);
+	 SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
+	 SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
+	 SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
+	 SWIG_RegisterMapping("_unsigned_int","_uint",0);
+	 SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_unsigned_int","_int",0);
+	 SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
+	 SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
+	 SWIG_RegisterMapping("_class_wxPyMenu","_wxPyMenu",0);
+	 SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
+	 SWIG_RegisterMapping("_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_short","_unsigned_short",0);
+	 SWIG_RegisterMapping("_short","_signed_short",0);
+	 SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0);
+	 SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
+	 SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
+	 SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0);
+	 SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
+	 SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
+	 SWIG_RegisterMapping("_wxWindowID","_EBool",0);
+	 SWIG_RegisterMapping("_wxWindowID","_uint",0);
+	 SWIG_RegisterMapping("_wxWindowID","_int",0);
+	 SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
+	 SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
+	 SWIG_RegisterMapping("_int","_EBool",0);
+	 SWIG_RegisterMapping("_int","_uint",0);
+	 SWIG_RegisterMapping("_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_int","_unsigned_int",0);
+	 SWIG_RegisterMapping("_int","_signed_int",0);
+	 SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0);
+	 SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0);
+	 SWIG_RegisterMapping("_wxButton","_class_wxButton",0);
+	 SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
+	 SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
+	 SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0);
+	 SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
+	 SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0);
+	 SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0);
+	 SWIG_RegisterMapping("_class_wxComboBox","_wxComboBox",0);
+	 SWIG_RegisterMapping("_class_wxRadioButton","_wxRadioButton",0);
+	 SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
+	 SWIG_RegisterMapping("_wxIconizeEvent","_class_wxIconizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxControl","_wxControl",0);
+	 SWIG_RegisterMapping("_wxStaticBitmap","_class_wxStaticBitmap",0);
+	 SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
+	 SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
+	 SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
+	 SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
+	 SWIG_RegisterMapping("_class_wxIdleEvent","_wxIdleEvent",0);
+	 SWIG_RegisterMapping("_wxEraseEvent","_class_wxEraseEvent",0);
+	 SWIG_RegisterMapping("_class_wxJoystickEvent","_wxJoystickEvent",0);
+	 SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0);
+	 SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
+	 SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
+	 SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
+	 SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
+	 SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0);
+	 SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0);
+	 SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
+	 SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
+	 SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
+	 SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
+	 SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
+	 SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
+	 SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0);
+	 SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
+	 SWIG_RegisterMapping("_wxDash","_long",0);
+	 SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
+	 SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0);
+	 SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0);
+	 SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
+	 SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0);
+	 SWIG_RegisterMapping("_wxMDIClientWindow","_class_wxMDIClientWindow",0);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
+	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxFrame",0);
+}

utils/wxPython/src/gtk/mdi.py

@@ -0,0 +1,131 @@
+# This file was created automatically by SWIG.
+import mdic
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from frames import *
+
+from stattool import *
+
+from controls import *
+
+from events import *
+import wx
+class wxMDIParentFramePtr(wxFramePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ActivateNext(self):
+        val = mdic.wxMDIParentFrame_ActivateNext(self.this)
+        return val
+    def ActivatePrevious(self):
+        val = mdic.wxMDIParentFrame_ActivatePrevious(self.this)
+        return val
+    def ArrangeIcons(self):
+        val = mdic.wxMDIParentFrame_ArrangeIcons(self.this)
+        return val
+    def Cascade(self):
+        val = mdic.wxMDIParentFrame_Cascade(self.this)
+        return val
+    def GetClientSize(self):
+        val = mdic.wxMDIParentFrame_GetClientSize(self.this)
+        return val
+    def GetActiveChild(self):
+        val = mdic.wxMDIParentFrame_GetActiveChild(self.this)
+        val = wxMDIChildFramePtr(val)
+        return val
+    def GetClientWindow(self):
+        val = mdic.wxMDIParentFrame_GetClientWindow(self.this)
+        val = wxMDIClientWindowPtr(val)
+        return val
+    def GetToolBar(self):
+        val = mdic.wxMDIParentFrame_GetToolBar(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def Tile(self):
+        val = mdic.wxMDIParentFrame_Tile(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMDIParentFrame instance>"
+class wxMDIParentFrame(wxMDIParentFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(mdic.new_wxMDIParentFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+class wxMDIChildFramePtr(wxFramePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Activate(self):
+        val = mdic.wxMDIChildFrame_Activate(self.this)
+        return val
+    def Maximize(self):
+        val = mdic.wxMDIChildFrame_Maximize(self.this)
+        return val
+    def Restore(self):
+        val = mdic.wxMDIChildFrame_Restore(self.this)
+        return val
+    def SetMenuBar(self,arg0):
+        val = mdic.wxMDIChildFrame_SetMenuBar(self.this,arg0.this)
+        return val
+    def SetClientSize(self,arg0,arg1):
+        val = mdic.wxMDIChildFrame_SetClientSize(self.this,arg0,arg1)
+        return val
+    def GetPosition(self):
+        val = mdic.wxMDIChildFrame_GetPosition(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMDIChildFrame instance>"
+class wxMDIChildFrame(wxMDIChildFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(mdic.new_wxMDIChildFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+class wxMDIClientWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMDIClientWindow instance>"
+class wxMDIClientWindow(wxMDIClientWindowPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(mdic.new_wxMDIClientWindow,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._StdOnScrollCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/misc.py

@@ -0,0 +1,617 @@
+# This file was created automatically by SWIG.
+import miscc
+class wxSizePtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxSize(self.this)
+    def Set(self,arg0,arg1):
+        val = miscc.wxSize_Set(self.this,arg0,arg1)
+        return val
+    def GetWidth(self):
+        val = miscc.wxSize_GetWidth(self.this)
+        return val
+    def GetHeight(self):
+        val = miscc.wxSize_GetHeight(self.this)
+        return val
+    def __str__(self):
+        val = miscc.wxSize___str__(self.this)
+        return val
+    def __setattr__(self,name,value):
+        if name == "width" :
+            miscc.wxSize_width_set(self.this,value)
+            return
+        if name == "height" :
+            miscc.wxSize_height_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "width" : 
+            return miscc.wxSize_width_get(self.this)
+        if name == "height" : 
+            return miscc.wxSize_height_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxSize instance>"
+class wxSize(wxSizePtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxSize,()+args)
+        self.thisown = 1
+
+
+
+
+class wxRealPointPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRealPoint(self.this)
+    def __setattr__(self,name,value):
+        if name == "x" :
+            miscc.wxRealPoint_x_set(self.this,value)
+            return
+        if name == "y" :
+            miscc.wxRealPoint_y_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "x" : 
+            return miscc.wxRealPoint_x_get(self.this)
+        if name == "y" : 
+            return miscc.wxRealPoint_y_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxRealPoint instance>"
+class wxRealPoint(wxRealPointPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxRealPoint,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPointPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxPoint(self.this)
+    def Set(self,arg0,arg1):
+        val = miscc.wxPoint_Set(self.this,arg0,arg1)
+        return val
+    def __str__(self):
+        val = miscc.wxPoint___str__(self.this)
+        return val
+    def __setattr__(self,name,value):
+        if name == "x" :
+            miscc.wxPoint_x_set(self.this,value)
+            return
+        if name == "y" :
+            miscc.wxPoint_y_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "x" : 
+            return miscc.wxPoint_x_get(self.this)
+        if name == "y" : 
+            return miscc.wxPoint_y_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxPoint instance>"
+class wxPoint(wxPointPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxPoint,()+args)
+        self.thisown = 1
+
+
+
+
+class wxRectPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRect(self.this)
+    def GetX(self):
+        val = miscc.wxRect_GetX(self.this)
+        return val
+    def SetX(self,arg0):
+        val = miscc.wxRect_SetX(self.this,arg0)
+        return val
+    def GetY(self):
+        val = miscc.wxRect_GetY(self.this)
+        return val
+    def SetY(self,arg0):
+        val = miscc.wxRect_SetY(self.this,arg0)
+        return val
+    def GetWidth(self):
+        val = miscc.wxRect_GetWidth(self.this)
+        return val
+    def SetWidth(self,arg0):
+        val = miscc.wxRect_SetWidth(self.this,arg0)
+        return val
+    def GetHeight(self):
+        val = miscc.wxRect_GetHeight(self.this)
+        return val
+    def SetHeight(self,arg0):
+        val = miscc.wxRect_SetHeight(self.this,arg0)
+        return val
+    def GetPosition(self):
+        val = miscc.wxRect_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetSize(self):
+        val = miscc.wxRect_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetLeft(self):
+        val = miscc.wxRect_GetLeft(self.this)
+        return val
+    def GetTop(self):
+        val = miscc.wxRect_GetTop(self.this)
+        return val
+    def GetBottom(self):
+        val = miscc.wxRect_GetBottom(self.this)
+        return val
+    def GetRight(self):
+        val = miscc.wxRect_GetRight(self.this)
+        return val
+    def __setattr__(self,name,value):
+        if name == "x" :
+            miscc.wxRect_x_set(self.this,value)
+            return
+        if name == "y" :
+            miscc.wxRect_y_set(self.this,value)
+            return
+        if name == "width" :
+            miscc.wxRect_width_set(self.this,value)
+            return
+        if name == "height" :
+            miscc.wxRect_height_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "x" : 
+            return miscc.wxRect_x_get(self.this)
+        if name == "y" : 
+            return miscc.wxRect_y_get(self.this)
+        if name == "width" : 
+            return miscc.wxRect_width_get(self.this)
+        if name == "height" : 
+            return miscc.wxRect_height_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxRect instance>"
+class wxRect(wxRectPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxRect,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPyTimerPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxPyTimer(self.this)
+    def Interval(self):
+        val = miscc.wxPyTimer_Interval(self.this)
+        return val
+    def Start(self,*args):
+        val = apply(miscc.wxPyTimer_Start,(self.this,)+args)
+        return val
+    def Stop(self):
+        val = miscc.wxPyTimer_Stop(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPyTimer instance>"
+class wxPyTimer(wxPyTimerPtr):
+    def __init__(self,arg0) :
+        self.this = miscc.new_wxPyTimer(arg0)
+        self.thisown = 1
+
+
+
+
+class wxIndividualLayoutConstraintPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Above(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_Above,(self.this,arg0.this,)+args)
+        return val
+    def Absolute(self,arg0):
+        val = miscc.wxIndividualLayoutConstraint_Absolute(self.this,arg0)
+        return val
+    def AsIs(self):
+        val = miscc.wxIndividualLayoutConstraint_AsIs(self.this)
+        return val
+    def Below(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_Below,(self.this,arg0.this,)+args)
+        return val
+    def Unconstrained(self):
+        val = miscc.wxIndividualLayoutConstraint_Unconstrained(self.this)
+        return val
+    def LeftOf(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_LeftOf,(self.this,arg0.this,)+args)
+        return val
+    def PercentOf(self,arg0,arg1,arg2):
+        val = miscc.wxIndividualLayoutConstraint_PercentOf(self.this,arg0.this,arg1,arg2)
+        return val
+    def RightOf(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_RightOf,(self.this,arg0.this,)+args)
+        return val
+    def SameAs(self,arg0,arg1,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_SameAs,(self.this,arg0.this,arg1,)+args)
+        return val
+    def Set(self,arg0,arg1,arg2,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_Set,(self.this,arg0,arg1.this,arg2,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxIndividualLayoutConstraint instance>"
+class wxIndividualLayoutConstraint(wxIndividualLayoutConstraintPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxLayoutConstraintsPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __setattr__(self,name,value):
+        if name == "bottom" :
+            miscc.wxLayoutConstraints_bottom_set(self.this,value.this)
+            return
+        if name == "centreX" :
+            miscc.wxLayoutConstraints_centreX_set(self.this,value.this)
+            return
+        if name == "centreY" :
+            miscc.wxLayoutConstraints_centreY_set(self.this,value.this)
+            return
+        if name == "height" :
+            miscc.wxLayoutConstraints_height_set(self.this,value.this)
+            return
+        if name == "left" :
+            miscc.wxLayoutConstraints_left_set(self.this,value.this)
+            return
+        if name == "right" :
+            miscc.wxLayoutConstraints_right_set(self.this,value.this)
+            return
+        if name == "top" :
+            miscc.wxLayoutConstraints_top_set(self.this,value.this)
+            return
+        if name == "width" :
+            miscc.wxLayoutConstraints_width_set(self.this,value.this)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "bottom" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_bottom_get(self.this))
+        if name == "centreX" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreX_get(self.this))
+        if name == "centreY" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreY_get(self.this))
+        if name == "height" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_height_get(self.this))
+        if name == "left" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_left_get(self.this))
+        if name == "right" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_right_get(self.this))
+        if name == "top" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_top_get(self.this))
+        if name == "width" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_width_get(self.this))
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxLayoutConstraints instance>"
+class wxLayoutConstraints(wxLayoutConstraintsPtr):
+    def __init__(self) :
+        self.this = miscc.new_wxLayoutConstraints()
+        self.thisown = 1
+
+
+
+
+class wxRegionPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRegion(self.this)
+    def Clear(self):
+        val = miscc.wxRegion_Clear(self.this)
+        return val
+    def Contains(self,arg0,arg1):
+        val = miscc.wxRegion_Contains(self.this,arg0,arg1)
+        return val
+    def ContainsPoint(self,arg0):
+        val = miscc.wxRegion_ContainsPoint(self.this,arg0.this)
+        return val
+    def ContainsRect(self,arg0):
+        val = miscc.wxRegion_ContainsRect(self.this,arg0.this)
+        return val
+    def GetBox(self):
+        val = miscc.wxRegion_GetBox(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def Intersect(self,arg0):
+        val = miscc.wxRegion_Intersect(self.this,arg0.this)
+        return val
+    def Subtract(self,arg0):
+        val = miscc.wxRegion_Subtract(self.this,arg0.this)
+        return val
+    def Union(self,arg0):
+        val = miscc.wxRegion_Union(self.this,arg0.this)
+        return val
+    def Xor(self,arg0):
+        val = miscc.wxRegion_Xor(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxRegion instance>"
+class wxRegion(wxRegionPtr):
+    def __init__(self) :
+        self.this = miscc.new_wxRegion()
+        self.thisown = 1
+
+
+
+
+class wxRegionIteratorPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRegionIterator(self.this)
+    def GetX(self):
+        val = miscc.wxRegionIterator_GetX(self.this)
+        return val
+    def GetY(self):
+        val = miscc.wxRegionIterator_GetY(self.this)
+        return val
+    def GetW(self):
+        val = miscc.wxRegionIterator_GetW(self.this)
+        return val
+    def GetWidth(self):
+        val = miscc.wxRegionIterator_GetWidth(self.this)
+        return val
+    def GetH(self):
+        val = miscc.wxRegionIterator_GetH(self.this)
+        return val
+    def GetHeight(self):
+        val = miscc.wxRegionIterator_GetHeight(self.this)
+        return val
+    def GetRect(self):
+        val = miscc.wxRegionIterator_GetRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def HaveRects(self):
+        val = miscc.wxRegionIterator_HaveRects(self.this)
+        return val
+    def Reset(self):
+        val = miscc.wxRegionIterator_Reset(self.this)
+        return val
+    def Next(self):
+        val = miscc.wxRegionIterator_Next(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxRegionIterator instance>"
+class wxRegionIterator(wxRegionIteratorPtr):
+    def __init__(self,arg0) :
+        self.this = miscc.new_wxRegionIterator(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxAcceleratorEntryPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Set(self,arg0,arg1,arg2):
+        val = miscc.wxAcceleratorEntry_Set(self.this,arg0,arg1,arg2)
+        return val
+    def GetFlags(self):
+        val = miscc.wxAcceleratorEntry_GetFlags(self.this)
+        return val
+    def GetKeyCode(self):
+        val = miscc.wxAcceleratorEntry_GetKeyCode(self.this)
+        return val
+    def GetCommand(self):
+        val = miscc.wxAcceleratorEntry_GetCommand(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxAcceleratorEntry instance>"
+class wxAcceleratorEntry(wxAcceleratorEntryPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxAcceleratorEntry,()+args)
+        self.thisown = 1
+
+
+
+
+class wxAcceleratorTablePtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxAcceleratorTable instance>"
+class wxAcceleratorTable(wxAcceleratorTablePtr):
+    def __init__(self,arg0) :
+        self.this = miscc.new_wxAcceleratorTable(arg0.this)
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+def wxFileSelector(arg0,*args):
+    argl = map(None,args)
+    try: argl[5] = argl[5].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxFileSelector,(arg0,)+args)
+    return val
+
+def wxGetTextFromUser(arg0,*args):
+    argl = map(None,args)
+    try: argl[2] = argl[2].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxGetTextFromUser,(arg0,)+args)
+    return val
+
+def wxGetSingleChoice(arg0,arg1,arg2,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxGetSingleChoice,(arg0,arg1,arg2,)+args)
+    return val
+
+def wxGetSingleChoiceIndex(arg0,arg1,arg2,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxGetSingleChoiceIndex,(arg0,arg1,arg2,)+args)
+    return val
+
+def wxMessageBox(arg0,*args):
+    argl = map(None,args)
+    try: argl[2] = argl[2].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxMessageBox,(arg0,)+args)
+    return val
+
+wxColourDisplay = miscc.wxColourDisplay
+
+wxDisplayDepth = miscc.wxDisplayDepth
+
+def wxSetCursor(arg0):
+    val = miscc.wxSetCursor(arg0.this)
+    return val
+
+NewId = miscc.NewId
+
+RegisterId = miscc.RegisterId
+
+def wxBeginBusyCursor(*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxBeginBusyCursor,()+args)
+    return val
+
+wxBell = miscc.wxBell
+
+wxDisplaySize = miscc.wxDisplaySize
+
+wxEndBusyCursor = miscc.wxEndBusyCursor
+
+wxExecute = miscc.wxExecute
+
+def wxFindWindowByLabel(arg0,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxFindWindowByLabel,(arg0,)+args)
+    val = wxWindowPtr(val)
+    return val
+
+def wxFindWindowByName(arg0,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxFindWindowByName,(arg0,)+args)
+    val = wxWindowPtr(val)
+    return val
+
+wxGetMousePosition = miscc.wxGetMousePosition
+
+wxIsBusy = miscc.wxIsBusy
+
+wxNow = miscc.wxNow
+
+wxYield = miscc.wxYield
+
+wxGetResource = miscc.wxGetResource
+
+wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
+
+wxResourceClear = miscc.wxResourceClear
+
+def wxResourceCreateBitmap(arg0):
+    val = miscc.wxResourceCreateBitmap(arg0)
+    val = wxBitmapPtr(val)
+    val.thisown = 1
+    return val
+
+def wxResourceCreateIcon(arg0):
+    val = miscc.wxResourceCreateIcon(arg0)
+    val = wxIconPtr(val)
+    val.thisown = 1
+    return val
+
+def wxResourceCreateMenuBar(arg0):
+    val = miscc.wxResourceCreateMenuBar(arg0)
+    val = wxMenuBarPtr(val)
+    return val
+
+wxResourceGetIdentifier = miscc.wxResourceGetIdentifier
+
+wxResourceParseData = miscc.wxResourceParseData
+
+wxResourceParseFile = miscc.wxResourceParseFile
+
+wxResourceParseString = miscc.wxResourceParseString
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxLeft = miscc.wxLeft
+wxTop = miscc.wxTop
+wxRight = miscc.wxRight
+wxBottom = miscc.wxBottom
+wxWidth = miscc.wxWidth
+wxHeight = miscc.wxHeight
+wxCentre = miscc.wxCentre
+wxCenter = miscc.wxCenter
+wxCentreX = miscc.wxCentreX
+wxCentreY = miscc.wxCentreY
+wxUnconstrained = miscc.wxUnconstrained
+wxAsIs = miscc.wxAsIs
+wxPercentOf = miscc.wxPercentOf
+wxAbove = miscc.wxAbove
+wxBelow = miscc.wxBelow
+wxLeftOf = miscc.wxLeftOf
+wxRightOf = miscc.wxRightOf
+wxSameAs = miscc.wxSameAs
+wxAbsolute = miscc.wxAbsolute
+wxOutRegion = miscc.wxOutRegion
+wxPartRegion = miscc.wxPartRegion
+wxInRegion = miscc.wxInRegion

utils/wxPython/src/gtk/stattool.py

@@ -0,0 +1,230 @@
+# This file was created automatically by SWIG.
+import stattoolc
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from controls import *
+
+from events import *
+import wx
+class wxStatusBarPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFieldRect(self,arg0):
+        val = stattoolc.wxStatusBar_GetFieldRect(self.this,arg0)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def GetFieldsCount(self):
+        val = stattoolc.wxStatusBar_GetFieldsCount(self.this)
+        return val
+    def GetStatusText(self,*args):
+        val = apply(stattoolc.wxStatusBar_GetStatusText,(self.this,)+args)
+        return val
+    def DrawField(self,arg0,arg1):
+        val = stattoolc.wxStatusBar_DrawField(self.this,arg0.this,arg1)
+        return val
+    def DrawFieldText(self,arg0,arg1):
+        val = stattoolc.wxStatusBar_DrawFieldText(self.this,arg0.this,arg1)
+        return val
+    def InitColours(self):
+        val = stattoolc.wxStatusBar_InitColours(self.this)
+        return val
+    def SetFieldsCount(self,*args):
+        val = apply(stattoolc.wxStatusBar_SetFieldsCount,(self.this,)+args)
+        return val
+    def SetStatusText(self,arg0,*args):
+        val = apply(stattoolc.wxStatusBar_SetStatusText,(self.this,arg0,)+args)
+        return val
+    def SetStatusWidths(self,arg0,*args):
+        val = apply(stattoolc.wxStatusBar_SetStatusWidths,(self.this,arg0,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxStatusBar instance>"
+class wxStatusBar(wxStatusBarPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(stattoolc.new_wxStatusBar,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxToolBarToolPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            stattoolc.delete_wxToolBarTool(self.this)
+    def __setattr__(self,name,value):
+        if name == "m_toolStyle" :
+            stattoolc.wxToolBarTool_m_toolStyle_set(self.this,value)
+            return
+        if name == "m_clientData" :
+            stattoolc.wxToolBarTool_m_clientData_set(self.this,value)
+            return
+        if name == "m_index" :
+            stattoolc.wxToolBarTool_m_index_set(self.this,value)
+            return
+        if name == "m_toggleState" :
+            stattoolc.wxToolBarTool_m_toggleState_set(self.this,value)
+            return
+        if name == "m_isToggle" :
+            stattoolc.wxToolBarTool_m_isToggle_set(self.this,value)
+            return
+        if name == "m_deleteSecondBitmap" :
+            stattoolc.wxToolBarTool_m_deleteSecondBitmap_set(self.this,value)
+            return
+        if name == "m_enabled" :
+            stattoolc.wxToolBarTool_m_enabled_set(self.this,value)
+            return
+        if name == "m_bitmap1" :
+            stattoolc.wxToolBarTool_m_bitmap1_set(self.this,value.this)
+            return
+        if name == "m_bitmap2" :
+            stattoolc.wxToolBarTool_m_bitmap2_set(self.this,value.this)
+            return
+        if name == "m_isMenuCommand" :
+            stattoolc.wxToolBarTool_m_isMenuCommand_set(self.this,value)
+            return
+        if name == "m_shortHelpString" :
+            stattoolc.wxToolBarTool_m_shortHelpString_set(self.this,value)
+            return
+        if name == "m_longHelpString" :
+            stattoolc.wxToolBarTool_m_longHelpString_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_toolStyle" : 
+            return stattoolc.wxToolBarTool_m_toolStyle_get(self.this)
+        if name == "m_clientData" : 
+            return stattoolc.wxToolBarTool_m_clientData_get(self.this)
+        if name == "m_index" : 
+            return stattoolc.wxToolBarTool_m_index_get(self.this)
+        if name == "m_toggleState" : 
+            return stattoolc.wxToolBarTool_m_toggleState_get(self.this)
+        if name == "m_isToggle" : 
+            return stattoolc.wxToolBarTool_m_isToggle_get(self.this)
+        if name == "m_deleteSecondBitmap" : 
+            return stattoolc.wxToolBarTool_m_deleteSecondBitmap_get(self.this)
+        if name == "m_enabled" : 
+            return stattoolc.wxToolBarTool_m_enabled_get(self.this)
+        if name == "m_bitmap1" : 
+            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap1_get(self.this))
+        if name == "m_bitmap2" : 
+            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap2_get(self.this))
+        if name == "m_isMenuCommand" : 
+            return stattoolc.wxToolBarTool_m_isMenuCommand_get(self.this)
+        if name == "m_shortHelpString" : 
+            return stattoolc.wxToolBarTool_m_shortHelpString_get(self.this)
+        if name == "m_longHelpString" : 
+            return stattoolc.wxToolBarTool_m_longHelpString_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxToolBarTool instance>"
+class wxToolBarTool(wxToolBarToolPtr):
+    def __init__(self) :
+        self.this = stattoolc.new_wxToolBarTool()
+        self.thisown = 1
+
+
+
+
+class wxToolBarPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def AddSeparator(self):
+        val = stattoolc.wxToolBar_AddSeparator(self.this)
+        return val
+    def AddTool(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(stattoolc.wxToolBar_AddTool,(self.this,arg0,arg1.this,)+args)
+        val = wxToolBarToolPtr(val)
+        return val
+    def AddSimpleTool(self,arg0,arg1,*args):
+        val = apply(stattoolc.wxToolBar_AddSimpleTool,(self.this,arg0,arg1.this,)+args)
+        val = wxToolBarToolPtr(val)
+        return val
+    def EnableTool(self,arg0,arg1):
+        val = stattoolc.wxToolBar_EnableTool(self.this,arg0,arg1)
+        return val
+    def GetToolEnabled(self,arg0):
+        val = stattoolc.wxToolBar_GetToolEnabled(self.this,arg0)
+        return val
+    def GetToolLongHelp(self,arg0):
+        val = stattoolc.wxToolBar_GetToolLongHelp(self.this,arg0)
+        return val
+    def GetToolPacking(self):
+        val = stattoolc.wxToolBar_GetToolPacking(self.this)
+        return val
+    def GetToolSeparation(self):
+        val = stattoolc.wxToolBar_GetToolSeparation(self.this)
+        return val
+    def GetToolShortHelp(self,arg0):
+        val = stattoolc.wxToolBar_GetToolShortHelp(self.this,arg0)
+        return val
+    def GetToolState(self,arg0):
+        val = stattoolc.wxToolBar_GetToolState(self.this,arg0)
+        return val
+    def Realize(self):
+        val = stattoolc.wxToolBar_Realize(self.this)
+        return val
+    def SetToolLongHelp(self,arg0,arg1):
+        val = stattoolc.wxToolBar_SetToolLongHelp(self.this,arg0,arg1)
+        return val
+    def SetToolShortHelp(self,arg0,arg1):
+        val = stattoolc.wxToolBar_SetToolShortHelp(self.this,arg0,arg1)
+        return val
+    def SetMargins(self,arg0):
+        val = stattoolc.wxToolBar_SetMargins(self.this,arg0.this)
+        return val
+    def SetToolPacking(self,arg0):
+        val = stattoolc.wxToolBar_SetToolPacking(self.this,arg0)
+        return val
+    def SetToolSeparation(self,arg0):
+        val = stattoolc.wxToolBar_SetToolSeparation(self.this,arg0)
+        return val
+    def ToggleTool(self,arg0,arg1):
+        val = stattoolc.wxToolBar_ToggleTool(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxToolBar instance>"
+class wxToolBar(wxToolBarPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(stattoolc.new_wxToolBar,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/utils.py

@@ -0,0 +1,114 @@
+# This file was created automatically by SWIG.
+import utilsc
+class wxConfigPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            utilsc.delete_wxConfig(self.this)
+    def DontCreateOnDemand(self):
+        val = utilsc.wxConfig_DontCreateOnDemand(self.this)
+        return val
+    def DeleteEntry(self,arg0,*args):
+        val = apply(utilsc.wxConfig_DeleteEntry,(self.this,arg0,)+args)
+        return val
+    def DeleteGroup(self,arg0):
+        val = utilsc.wxConfig_DeleteGroup(self.this,arg0)
+        return val
+    def Exists(self,arg0):
+        val = utilsc.wxConfig_Exists(self.this,arg0)
+        return val
+    def Flush(self,*args):
+        val = apply(utilsc.wxConfig_Flush,(self.this,)+args)
+        return val
+    def GetAppName(self):
+        val = utilsc.wxConfig_GetAppName(self.this)
+        return val
+    def GetFirstGroup(self):
+        val = utilsc.wxConfig_GetFirstGroup(self.this)
+        return val
+    def GetFirstEntry(self):
+        val = utilsc.wxConfig_GetFirstEntry(self.this)
+        return val
+    def GetNextGroup(self,arg0):
+        val = utilsc.wxConfig_GetNextGroup(self.this,arg0)
+        return val
+    def GetNextEntry(self,arg0):
+        val = utilsc.wxConfig_GetNextEntry(self.this,arg0)
+        return val
+    def GetNumberOfEntries(self,*args):
+        val = apply(utilsc.wxConfig_GetNumberOfEntries,(self.this,)+args)
+        return val
+    def GetNumberOfGroups(self,*args):
+        val = apply(utilsc.wxConfig_GetNumberOfGroups,(self.this,)+args)
+        return val
+    def GetPath(self):
+        val = utilsc.wxConfig_GetPath(self.this)
+        return val
+    def GetVendorName(self):
+        val = utilsc.wxConfig_GetVendorName(self.this)
+        return val
+    def HasEntry(self,arg0):
+        val = utilsc.wxConfig_HasEntry(self.this,arg0)
+        return val
+    def HasGroup(self,arg0):
+        val = utilsc.wxConfig_HasGroup(self.this,arg0)
+        return val
+    def IsExpandingEnvVars(self):
+        val = utilsc.wxConfig_IsExpandingEnvVars(self.this)
+        return val
+    def IsRecordingDefaults(self):
+        val = utilsc.wxConfig_IsRecordingDefaults(self.this)
+        return val
+    def Read(self,arg0,*args):
+        val = apply(utilsc.wxConfig_Read,(self.this,arg0,)+args)
+        return val
+    def ReadInt(self,arg0,*args):
+        val = apply(utilsc.wxConfig_ReadInt,(self.this,arg0,)+args)
+        return val
+    def ReadFloat(self,arg0,*args):
+        val = apply(utilsc.wxConfig_ReadFloat,(self.this,arg0,)+args)
+        return val
+    def SetAppName(self,arg0):
+        val = utilsc.wxConfig_SetAppName(self.this,arg0)
+        return val
+    def SetExpandEnvVars(self,*args):
+        val = apply(utilsc.wxConfig_SetExpandEnvVars,(self.this,)+args)
+        return val
+    def SetPath(self,arg0):
+        val = utilsc.wxConfig_SetPath(self.this,arg0)
+        return val
+    def SetRecordDefaults(self,*args):
+        val = apply(utilsc.wxConfig_SetRecordDefaults,(self.this,)+args)
+        return val
+    def SetVendorName(self,arg0):
+        val = utilsc.wxConfig_SetVendorName(self.this,arg0)
+        return val
+    def Write(self,arg0,arg1):
+        val = utilsc.wxConfig_Write(self.this,arg0,arg1)
+        return val
+    def WriteInt(self,arg0,arg1):
+        val = utilsc.wxConfig_WriteInt(self.this,arg0,arg1)
+        return val
+    def WriteFloat(self,arg0,arg1):
+        val = utilsc.wxConfig_WriteFloat(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxConfig instance>"
+class wxConfig(wxConfigPtr):
+    def __init__(self,*args) :
+        self.this = apply(utilsc.new_wxConfig,()+args)
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/windows.py

@@ -0,0 +1,627 @@
+# This file was created automatically by SWIG.
+import windowsc
+
+from misc import *
+
+from gdi import *
+import wx
+
+def wxDLG_PNT(win, point):
+    return win.ConvertDialogPointToPixels(point)
+
+def wxDLG_SZE(win, size):
+    return win.ConvertDialogPointToPixels(size)
+
+class wxEvtHandlerPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Connect(self,arg0,arg1,arg2,arg3):
+        val = windowsc.wxEvtHandler_Connect(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def __repr__(self):
+        return "<C wxEvtHandler instance>"
+class wxEvtHandler(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxWindowPtr(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def CaptureMouse(self):
+        val = windowsc.wxWindow_CaptureMouse(self.this)
+        return val
+    def Center(self,*args):
+        val = apply(windowsc.wxWindow_Center,(self.this,)+args)
+        return val
+    def Centre(self,*args):
+        val = apply(windowsc.wxWindow_Centre,(self.this,)+args)
+        return val
+    def ClientToScreen(self,arg0,arg1):
+        val = windowsc.wxWindow_ClientToScreen(self.this,arg0,arg1)
+        return val
+    def Close(self,*args):
+        val = apply(windowsc.wxWindow_Close,(self.this,)+args)
+        return val
+    def Destroy(self):
+        val = windowsc.wxWindow_Destroy(self.this)
+        return val
+    def DestroyChildren(self):
+        val = windowsc.wxWindow_DestroyChildren(self.this)
+        return val
+    def Enable(self,arg0):
+        val = windowsc.wxWindow_Enable(self.this,arg0)
+        return val
+    def FindWindowByID(self,arg0):
+        val = windowsc.wxWindow_FindWindowByID(self.this,arg0)
+        val = wxWindowPtr(val)
+        return val
+    def FindWindowByName(self,arg0):
+        val = windowsc.wxWindow_FindWindowByName(self.this,arg0)
+        val = wxWindowPtr(val)
+        return val
+    def Fit(self):
+        val = windowsc.wxWindow_Fit(self.this)
+        return val
+    def GetBackgroundColour(self):
+        val = windowsc.wxWindow_GetBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def GetCharHeight(self):
+        val = windowsc.wxWindow_GetCharHeight(self.this)
+        return val
+    def GetCharWidth(self):
+        val = windowsc.wxWindow_GetCharWidth(self.this)
+        return val
+    def GetClientSizeTuple(self):
+        val = windowsc.wxWindow_GetClientSizeTuple(self.this)
+        return val
+    def GetClientSize(self):
+        val = windowsc.wxWindow_GetClientSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetConstraints(self):
+        val = windowsc.wxWindow_GetConstraints(self.this)
+        val = wxLayoutConstraintsPtr(val)
+        return val
+    def GetFont(self):
+        val = windowsc.wxWindow_GetFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetForegroundColour(self):
+        val = windowsc.wxWindow_GetForegroundColour(self.this)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def GetGrandParent(self):
+        val = windowsc.wxWindow_GetGrandParent(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def GetId(self):
+        val = windowsc.wxWindow_GetId(self.this)
+        return val
+    def GetLabel(self):
+        val = windowsc.wxWindow_GetLabel(self.this)
+        return val
+    def GetName(self):
+        val = windowsc.wxWindow_GetName(self.this)
+        return val
+    def GetParent(self):
+        val = windowsc.wxWindow_GetParent(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def GetPositionTuple(self):
+        val = windowsc.wxWindow_GetPositionTuple(self.this)
+        return val
+    def GetPosition(self):
+        val = windowsc.wxWindow_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetRect(self):
+        val = windowsc.wxWindow_GetRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def GetReturnCode(self):
+        val = windowsc.wxWindow_GetReturnCode(self.this)
+        return val
+    def GetScrollThumb(self,arg0):
+        val = windowsc.wxWindow_GetScrollThumb(self.this,arg0)
+        return val
+    def GetScrollPos(self,arg0):
+        val = windowsc.wxWindow_GetScrollPos(self.this,arg0)
+        return val
+    def GetScrollRange(self,arg0):
+        val = windowsc.wxWindow_GetScrollRange(self.this,arg0)
+        return val
+    def GetSizeTuple(self):
+        val = windowsc.wxWindow_GetSizeTuple(self.this)
+        return val
+    def GetSize(self):
+        val = windowsc.wxWindow_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetTextExtent(self,arg0):
+        val = windowsc.wxWindow_GetTextExtent(self.this,arg0)
+        return val
+    def GetTitle(self):
+        val = windowsc.wxWindow_GetTitle(self.this)
+        return val
+    def GetWindowStyleFlag(self):
+        val = windowsc.wxWindow_GetWindowStyleFlag(self.this)
+        return val
+    def InitDialog(self):
+        val = windowsc.wxWindow_InitDialog(self.this)
+        return val
+    def IsEnabled(self):
+        val = windowsc.wxWindow_IsEnabled(self.this)
+        return val
+    def IsRetained(self):
+        val = windowsc.wxWindow_IsRetained(self.this)
+        return val
+    def IsShown(self):
+        val = windowsc.wxWindow_IsShown(self.this)
+        return val
+    def Layout(self):
+        val = windowsc.wxWindow_Layout(self.this)
+        return val
+    def LoadFromResource(self,arg0,arg1,*args):
+        val = apply(windowsc.wxWindow_LoadFromResource,(self.this,arg0.this,arg1,)+args)
+        return val
+    def Lower(self):
+        val = windowsc.wxWindow_Lower(self.this)
+        return val
+    def MakeModal(self,arg0):
+        val = windowsc.wxWindow_MakeModal(self.this,arg0)
+        return val
+    def Move(self,arg0,arg1):
+        val = windowsc.wxWindow_Move(self.this,arg0,arg1)
+        return val
+    def PopupMenu(self,arg0,arg1,arg2):
+        val = windowsc.wxWindow_PopupMenu(self.this,arg0.this,arg1,arg2)
+        return val
+    def Raise(self):
+        val = windowsc.wxWindow_Raise(self.this)
+        return val
+    def Refresh(self,*args):
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windowsc.wxWindow_Refresh,(self.this,)+args)
+        return val
+    def ReleaseMouse(self):
+        val = windowsc.wxWindow_ReleaseMouse(self.this)
+        return val
+    def ScreenToClient(self,arg0,arg1):
+        val = windowsc.wxWindow_ScreenToClient(self.this,arg0,arg1)
+        return val
+    def ScrollWindow(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windowsc.wxWindow_ScrollWindow,(self.this,arg0,arg1,)+args)
+        return val
+    def SetAcceleratorTable(self,arg0):
+        val = windowsc.wxWindow_SetAcceleratorTable(self.this,arg0.this)
+        return val
+    def SetAutoLayout(self,arg0):
+        val = windowsc.wxWindow_SetAutoLayout(self.this,arg0)
+        return val
+    def SetBackgroundColour(self,arg0):
+        val = windowsc.wxWindow_SetBackgroundColour(self.this,arg0.this)
+        return val
+    def SetConstraints(self,arg0):
+        val = windowsc.wxWindow_SetConstraints(self.this,arg0.this)
+        return val
+    def SetDoubleClick(self,arg0):
+        val = windowsc.wxWindow_SetDoubleClick(self.this,arg0)
+        return val
+    def SetFocus(self):
+        val = windowsc.wxWindow_SetFocus(self.this)
+        return val
+    def SetFont(self,arg0):
+        val = windowsc.wxWindow_SetFont(self.this,arg0.this)
+        return val
+    def SetForegroundColour(self,arg0):
+        val = windowsc.wxWindow_SetForegroundColour(self.this,arg0.this)
+        return val
+    def SetId(self,arg0):
+        val = windowsc.wxWindow_SetId(self.this,arg0)
+        return val
+    def SetName(self,arg0):
+        val = windowsc.wxWindow_SetName(self.this,arg0)
+        return val
+    def SetReturnCode(self,arg0):
+        val = windowsc.wxWindow_SetReturnCode(self.this,arg0)
+        return val
+    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(windowsc.wxWindow_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def SetScrollPos(self,arg0,arg1,*args):
+        val = apply(windowsc.wxWindow_SetScrollPos,(self.this,arg0,arg1,)+args)
+        return val
+    def SetDimensions(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(windowsc.wxWindow_SetDimensions,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def SetSize(self,arg0):
+        val = windowsc.wxWindow_SetSize(self.this,arg0.this)
+        return val
+    def SetPosition(self,arg0):
+        val = windowsc.wxWindow_SetPosition(self.this,arg0.this)
+        return val
+    def SetSizeHints(self,*args):
+        val = apply(windowsc.wxWindow_SetSizeHints,(self.this,)+args)
+        return val
+    def SetClientSize(self,arg0,arg1):
+        val = windowsc.wxWindow_SetClientSize(self.this,arg0,arg1)
+        return val
+    def SetCursor(self,arg0):
+        val = windowsc.wxWindow_SetCursor(self.this,arg0.this)
+        return val
+    def SetTitle(self,arg0):
+        val = windowsc.wxWindow_SetTitle(self.this,arg0)
+        return val
+    def Show(self,arg0):
+        val = windowsc.wxWindow_Show(self.this,arg0)
+        return val
+    def TransferDataFromWindow(self):
+        val = windowsc.wxWindow_TransferDataFromWindow(self.this)
+        return val
+    def TransferDataToWindow(self):
+        val = windowsc.wxWindow_TransferDataToWindow(self.this)
+        return val
+    def Validate(self):
+        val = windowsc.wxWindow_Validate(self.this)
+        return val
+    def WarpPointer(self,arg0,arg1):
+        val = windowsc.wxWindow_WarpPointer(self.this,arg0,arg1)
+        return val
+    def ConvertDialogPointToPixels(self,arg0):
+        val = windowsc.wxWindow_ConvertDialogPointToPixels(self.this,arg0.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def ConvertDialogSizeToPixels(self,arg0):
+        val = windowsc.wxWindow_ConvertDialogSizeToPixels(self.this,arg0.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def ConvertPixelPointToDialog(self,arg0):
+        val = windowsc.wxWindow_ConvertPixelPointToDialog(self.this,arg0.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def ConvertPixelSizeToDialog(self,arg0):
+        val = windowsc.wxWindow_ConvertPixelSizeToDialog(self.this,arg0.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxWindow instance>"
+class wxWindow(wxWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxPanelPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def InitDialog(self):
+        val = windowsc.wxPanel_InitDialog(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPanel instance>"
+class wxPanel(wxPanelPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxPanel,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxDialogPtr(wxPanelPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Centre(self,*args):
+        val = apply(windowsc.wxDialog_Centre,(self.this,)+args)
+        return val
+    def EndModal(self,arg0):
+        val = windowsc.wxDialog_EndModal(self.this,arg0)
+        return val
+    def GetTitle(self):
+        val = windowsc.wxDialog_GetTitle(self.this)
+        return val
+    def Iconize(self,arg0):
+        val = windowsc.wxDialog_Iconize(self.this,arg0)
+        return val
+    def IsIconized(self):
+        val = windowsc.wxDialog_IsIconized(self.this)
+        return val
+    def SetModal(self,arg0):
+        val = windowsc.wxDialog_SetModal(self.this,arg0)
+        return val
+    def IsModal(self):
+        val = windowsc.wxDialog_IsModal(self.this)
+        return val
+    def SetTitle(self,arg0):
+        val = windowsc.wxDialog_SetTitle(self.this,arg0)
+        return val
+    def Show(self,arg0):
+        val = windowsc.wxDialog_Show(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = windowsc.wxDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDialog instance>"
+class wxDialog(wxDialogPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxDialog,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxScrolledWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def EnableScrolling(self,arg0,arg1):
+        val = windowsc.wxScrolledWindow_EnableScrolling(self.this,arg0,arg1)
+        return val
+    def GetScrollPixelsPerUnit(self):
+        val = windowsc.wxScrolledWindow_GetScrollPixelsPerUnit(self.this)
+        return val
+    def GetVirtualSize(self):
+        val = windowsc.wxScrolledWindow_GetVirtualSize(self.this)
+        return val
+    def IsRetained(self):
+        val = windowsc.wxScrolledWindow_IsRetained(self.this)
+        return val
+    def PrepareDC(self,arg0):
+        val = windowsc.wxScrolledWindow_PrepareDC(self.this,arg0.this)
+        return val
+    def Scroll(self,arg0,arg1):
+        val = windowsc.wxScrolledWindow_Scroll(self.this,arg0,arg1)
+        return val
+    def SetScrollbars(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(windowsc.wxScrolledWindow_SetScrollbars,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def ViewStart(self):
+        val = windowsc.wxScrolledWindow_ViewStart(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScrolledWindow instance>"
+class wxScrolledWindow(wxScrolledWindowPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxScrolledWindow,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._StdOnScrollCallbacks(self)
+
+
+
+
+class wxMenuPtr(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0,arg1,*args):
+        val = apply(windowsc.wxMenu_Append,(self.this,arg0,arg1,)+args)
+        return val
+    def AppendMenu(self,arg0,arg1,arg2,*args):
+        val = apply(windowsc.wxMenu_AppendMenu,(self.this,arg0,arg1,arg2.this,)+args)
+        return val
+    def AppendSeparator(self):
+        val = windowsc.wxMenu_AppendSeparator(self.this)
+        return val
+    def Break(self):
+        val = windowsc.wxMenu_Break(self.this)
+        return val
+    def Check(self,arg0,arg1):
+        val = windowsc.wxMenu_Check(self.this,arg0,arg1)
+        return val
+    def Enable(self,arg0,arg1):
+        val = windowsc.wxMenu_Enable(self.this,arg0,arg1)
+        return val
+    def FindItem(self,arg0):
+        val = windowsc.wxMenu_FindItem(self.this,arg0)
+        return val
+    def GetTitle(self):
+        val = windowsc.wxMenu_GetTitle(self.this)
+        return val
+    def SetTitle(self,arg0):
+        val = windowsc.wxMenu_SetTitle(self.this,arg0)
+        return val
+    def FindItemForId(self,arg0):
+        val = windowsc.wxMenu_FindItemForId(self.this,arg0)
+        val = wxMenuItemPtr(val)
+        return val
+    def GetHelpString(self,arg0):
+        val = windowsc.wxMenu_GetHelpString(self.this,arg0)
+        return val
+    def GetLabel(self,arg0):
+        val = windowsc.wxMenu_GetLabel(self.this,arg0)
+        return val
+    def SetHelpString(self,arg0,arg1):
+        val = windowsc.wxMenu_SetHelpString(self.this,arg0,arg1)
+        return val
+    def IsChecked(self,arg0):
+        val = windowsc.wxMenu_IsChecked(self.this,arg0)
+        return val
+    def IsEnabled(self,arg0):
+        val = windowsc.wxMenu_IsEnabled(self.this,arg0)
+        return val
+    def SetLabel(self,arg0,arg1):
+        val = windowsc.wxMenu_SetLabel(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxMenu instance>"
+class wxMenu(wxMenuPtr):
+    def __init__(self,*args) :
+        self.this = apply(windowsc.new_wxMenu,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPyMenuPtr(wxMenuPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            windowsc.delete_wxPyMenu(self.this)
+    def __repr__(self):
+        return "<C wxPyMenu instance>"
+class wxPyMenu(wxPyMenuPtr):
+    def __init__(self,*args) :
+        self.this = apply(windowsc.new_wxPyMenu,()+args)
+        self.thisown = 1
+
+
+
+
+class wxMenuBarPtr(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0,arg1):
+        val = windowsc.wxMenuBar_Append(self.this,arg0.this,arg1)
+        return val
+    def Check(self,arg0,arg1):
+        val = windowsc.wxMenuBar_Check(self.this,arg0,arg1)
+        return val
+    def Checked(self,arg0):
+        val = windowsc.wxMenuBar_Checked(self.this,arg0)
+        return val
+    def Enable(self,arg0,arg1):
+        val = windowsc.wxMenuBar_Enable(self.this,arg0,arg1)
+        return val
+    def Enabled(self,arg0):
+        val = windowsc.wxMenuBar_Enabled(self.this,arg0)
+        return val
+    def FindMenuItem(self,arg0,arg1):
+        val = windowsc.wxMenuBar_FindMenuItem(self.this,arg0,arg1)
+        return val
+    def FindItemForId(self,arg0):
+        val = windowsc.wxMenuBar_FindItemForId(self.this,arg0)
+        val = wxMenuItemPtr(val)
+        return val
+    def GetMenuCount(self):
+        val = windowsc.wxMenuBar_GetMenuCount(self.this)
+        return val
+    def GetMenu(self,arg0):
+        val = windowsc.wxMenuBar_GetMenu(self.this,arg0)
+        val = wxMenuPtr(val)
+        return val
+    def __repr__(self):
+        return "<C wxMenuBar instance>"
+class wxMenuBar(wxMenuBarPtr):
+    def __init__(self) :
+        self.this = windowsc.new_wxMenuBar()
+        self.thisown = 1
+
+
+
+
+class wxMenuItemPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsSeparator(self):
+        val = windowsc.wxMenuItem_IsSeparator(self.this)
+        return val
+    def IsEnabled(self):
+        val = windowsc.wxMenuItem_IsEnabled(self.this)
+        return val
+    def IsChecked(self):
+        val = windowsc.wxMenuItem_IsChecked(self.this)
+        return val
+    def IsCheckable(self):
+        val = windowsc.wxMenuItem_IsCheckable(self.this)
+        return val
+    def GetId(self):
+        val = windowsc.wxMenuItem_GetId(self.this)
+        return val
+    def GetSubMenu(self):
+        val = windowsc.wxMenuItem_GetSubMenu(self.this)
+        val = wxMenuPtr(val)
+        return val
+    def SetName(self,arg0):
+        val = windowsc.wxMenuItem_SetName(self.this,arg0)
+        return val
+    def GetName(self):
+        val = windowsc.wxMenuItem_GetName(self.this)
+        return val
+    def GetHelp(self):
+        val = windowsc.wxMenuItem_GetHelp(self.this)
+        return val
+    def SetHelp(self,arg0):
+        val = windowsc.wxMenuItem_SetHelp(self.this,arg0)
+        return val
+    def Enable(self,*args):
+        val = apply(windowsc.wxMenuItem_Enable,(self.this,)+args)
+        return val
+    def Check(self,*args):
+        val = apply(windowsc.wxMenuItem_Check,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxMenuItem instance>"
+class wxMenuItem(wxMenuItemPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/windows2.py

@@ -0,0 +1,545 @@
+# This file was created automatically by SWIG.
+import windows2c
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+
+from controls import *
+
+from events import *
+import wx
+class wxGridCellPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            windows2c.delete_wxGridCell(self.this)
+    def GetTextValue(self):
+        val = windows2c.wxGridCell_GetTextValue(self.this)
+        return val
+    def SetTextValue(self,arg0):
+        val = windows2c.wxGridCell_SetTextValue(self.this,arg0)
+        return val
+    def GetFont(self):
+        val = windows2c.wxGridCell_GetFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def SetFont(self,arg0):
+        val = windows2c.wxGridCell_SetFont(self.this,arg0.this)
+        return val
+    def GetTextColour(self):
+        val = windows2c.wxGridCell_GetTextColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def SetTextColour(self,arg0):
+        val = windows2c.wxGridCell_SetTextColour(self.this,arg0.this)
+        return val
+    def GetBackgroundColour(self):
+        val = windows2c.wxGridCell_GetBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def SetBackgroundColour(self,arg0):
+        val = windows2c.wxGridCell_SetBackgroundColour(self.this,arg0.this)
+        return val
+    def GetBackgroundBrush(self):
+        val = windows2c.wxGridCell_GetBackgroundBrush(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetAlignment(self):
+        val = windows2c.wxGridCell_GetAlignment(self.this)
+        return val
+    def SetAlignment(self,arg0):
+        val = windows2c.wxGridCell_SetAlignment(self.this,arg0)
+        return val
+    def GetCellBitmap(self):
+        val = windows2c.wxGridCell_GetCellBitmap(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetCellBitmap(self,arg0):
+        val = windows2c.wxGridCell_SetCellBitmap(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxGridCell instance>"
+class wxGridCell(wxGridCellPtr):
+    def __init__(self) :
+        self.this = windows2c.new_wxGridCell()
+        self.thisown = 1
+
+
+
+
+class wxGridPtr(wxPanelPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def AdjustScrollbars(self):
+        val = windows2c.wxGrid_AdjustScrollbars(self.this)
+        return val
+    def AppendCols(self,*args):
+        val = apply(windows2c.wxGrid_AppendCols,(self.this,)+args)
+        return val
+    def AppendRows(self,*args):
+        val = apply(windows2c.wxGrid_AppendRows,(self.this,)+args)
+        return val
+    def BeginBatch(self):
+        val = windows2c.wxGrid_BeginBatch(self.this)
+        return val
+    def CellHitTest(self,arg0,arg1):
+        val = windows2c.wxGrid_CellHitTest(self.this,arg0,arg1)
+        return val
+    def CreateGrid(self,arg0,arg1,*args):
+        val = apply(windows2c.wxGrid_CreateGrid,(self.this,arg0,arg1,)+args)
+        return val
+    def CurrentCellVisible(self):
+        val = windows2c.wxGrid_CurrentCellVisible(self.this)
+        return val
+    def DeleteCols(self,*args):
+        val = apply(windows2c.wxGrid_DeleteCols,(self.this,)+args)
+        return val
+    def DeleteRows(self,*args):
+        val = apply(windows2c.wxGrid_DeleteRows,(self.this,)+args)
+        return val
+    def EndBatch(self):
+        val = windows2c.wxGrid_EndBatch(self.this)
+        return val
+    def GetBatchCount(self):
+        val = windows2c.wxGrid_GetBatchCount(self.this)
+        return val
+    def GetCell(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCell(self.this,arg0,arg1)
+        val = wxGridCellPtr(val)
+        return val
+    def GetCellAlignment(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellAlignment(self.this,arg0,arg1)
+        return val
+    def GetDefCellAlignment(self):
+        val = windows2c.wxGrid_GetDefCellAlignment(self.this)
+        return val
+    def GetCellBackgroundColour(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellBackgroundColour(self.this,arg0,arg1)
+        val = wxColourPtr(val)
+        return val
+    def GetDefCellBackgroundColour(self):
+        val = windows2c.wxGrid_GetDefCellBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetCellTextColour(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellTextColour(self.this,arg0,arg1)
+        val = wxColourPtr(val)
+        return val
+    def GetDefCellTextColour(self):
+        val = windows2c.wxGrid_GetDefCellTextColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetCellTextFont(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellTextFont(self.this,arg0,arg1)
+        val = wxFontPtr(val)
+        return val
+    def GetDefCellTextFont(self):
+        val = windows2c.wxGrid_GetDefCellTextFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetCellValue(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellValue(self.this,arg0,arg1)
+        return val
+    def GetCols(self):
+        val = windows2c.wxGrid_GetCols(self.this)
+        return val
+    def GetColumnWidth(self,arg0):
+        val = windows2c.wxGrid_GetColumnWidth(self.this,arg0)
+        return val
+    def GetCurrentRect(self):
+        val = windows2c.wxGrid_GetCurrentRect(self.this)
+        val = wxRectPtr(val)
+        return val
+    def GetCursorColumn(self):
+        val = windows2c.wxGrid_GetCursorColumn(self.this)
+        return val
+    def GetCursorRow(self):
+        val = windows2c.wxGrid_GetCursorRow(self.this)
+        return val
+    def GetEditable(self):
+        val = windows2c.wxGrid_GetEditable(self.this)
+        return val
+    def GetHorizScrollBar(self):
+        val = windows2c.wxGrid_GetHorizScrollBar(self.this)
+        val = wxScrollBarPtr(val)
+        return val
+    def GetLabelAlignment(self,arg0):
+        val = windows2c.wxGrid_GetLabelAlignment(self.this,arg0)
+        return val
+    def GetLabelBackgroundColour(self):
+        val = windows2c.wxGrid_GetLabelBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetLabelSize(self,arg0):
+        val = windows2c.wxGrid_GetLabelSize(self.this,arg0)
+        return val
+    def GetLabelTextColour(self):
+        val = windows2c.wxGrid_GetLabelTextColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetLabelTextFont(self):
+        val = windows2c.wxGrid_GetLabelTextFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetLabelValue(self,arg0,arg1):
+        val = windows2c.wxGrid_GetLabelValue(self.this,arg0,arg1)
+        return val
+    def GetRowHeight(self,arg0):
+        val = windows2c.wxGrid_GetRowHeight(self.this,arg0)
+        return val
+    def GetRows(self):
+        val = windows2c.wxGrid_GetRows(self.this)
+        return val
+    def GetScrollPosX(self):
+        val = windows2c.wxGrid_GetScrollPosX(self.this)
+        return val
+    def GetScrollPosY(self):
+        val = windows2c.wxGrid_GetScrollPosY(self.this)
+        return val
+    def GetTextItem(self):
+        val = windows2c.wxGrid_GetTextItem(self.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def GetVertScrollBar(self):
+        val = windows2c.wxGrid_GetVertScrollBar(self.this)
+        val = wxScrollBarPtr(val)
+        return val
+    def InsertCols(self,*args):
+        val = apply(windows2c.wxGrid_InsertCols,(self.this,)+args)
+        return val
+    def InsertRows(self,*args):
+        val = apply(windows2c.wxGrid_InsertRows,(self.this,)+args)
+        return val
+    def OnActivate(self,arg0):
+        val = windows2c.wxGrid_OnActivate(self.this,arg0)
+        return val
+    def SetCellAlignment(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellAlignment(self.this,arg0,arg1,arg2)
+        return val
+    def SetDefCellAlignment(self,arg0):
+        val = windows2c.wxGrid_SetDefCellAlignment(self.this,arg0)
+        return val
+    def SetCellBackgroundColour(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellBackgroundColour(self.this,arg0.this,arg1,arg2)
+        return val
+    def SetDefCellBackgroundColour(self,arg0):
+        val = windows2c.wxGrid_SetDefCellBackgroundColour(self.this,arg0.this)
+        return val
+    def SetCellTextColour(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellTextColour(self.this,arg0.this,arg1,arg2)
+        return val
+    def SetDefCellTextColour(self,arg0):
+        val = windows2c.wxGrid_SetDefCellTextColour(self.this,arg0.this)
+        return val
+    def SetCellTextFont(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellTextFont(self.this,arg0.this,arg1,arg2)
+        return val
+    def SetDefCellTextFont(self,arg0):
+        val = windows2c.wxGrid_SetDefCellTextFont(self.this,arg0.this)
+        return val
+    def SetCellValue(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellValue(self.this,arg0,arg1,arg2)
+        return val
+    def SetColumnWidth(self,arg0,arg1):
+        val = windows2c.wxGrid_SetColumnWidth(self.this,arg0,arg1)
+        return val
+    def SetDividerPen(self,arg0):
+        val = windows2c.wxGrid_SetDividerPen(self.this,arg0.this)
+        return val
+    def SetEditable(self,arg0):
+        val = windows2c.wxGrid_SetEditable(self.this,arg0)
+        return val
+    def SetGridCursor(self,arg0,arg1):
+        val = windows2c.wxGrid_SetGridCursor(self.this,arg0,arg1)
+        return val
+    def SetLabelAlignment(self,arg0,arg1):
+        val = windows2c.wxGrid_SetLabelAlignment(self.this,arg0,arg1)
+        return val
+    def SetLabelBackgroundColour(self,arg0):
+        val = windows2c.wxGrid_SetLabelBackgroundColour(self.this,arg0.this)
+        return val
+    def SetLabelSize(self,arg0,arg1):
+        val = windows2c.wxGrid_SetLabelSize(self.this,arg0,arg1)
+        return val
+    def SetLabelTextColour(self,arg0):
+        val = windows2c.wxGrid_SetLabelTextColour(self.this,arg0.this)
+        return val
+    def SetLabelTextFont(self,arg0):
+        val = windows2c.wxGrid_SetLabelTextFont(self.this,arg0.this)
+        return val
+    def SetLabelValue(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetLabelValue(self.this,arg0,arg1,arg2)
+        return val
+    def SetRowHeight(self,arg0,arg1):
+        val = windows2c.wxGrid_SetRowHeight(self.this,arg0,arg1)
+        return val
+    def UpdateDimensions(self):
+        val = windows2c.wxGrid_UpdateDimensions(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxGrid instance>"
+class wxGrid(wxGridPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows2c.new_wxGrid,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._checkForCallback(self, 'OnSelectCell',           wxEVT_GRID_SELECT_CELL)
+        wx._checkForCallback(self, 'OnCreateCell',           wxEVT_GRID_CREATE_CELL)
+        wx._checkForCallback(self, 'OnChangeLabels',         wxEVT_GRID_CHANGE_LABELS)
+        wx._checkForCallback(self, 'OnChangeSelectionLabel', wxEVT_GRID_CHANGE_SEL_LABEL)
+        wx._checkForCallback(self, 'OnCellChange',           wxEVT_GRID_CELL_CHANGE)
+        wx._checkForCallback(self, 'OnCellLeftClick',        wxEVT_GRID_CELL_LCLICK)
+        wx._checkForCallback(self, 'OnCellRightClick',       wxEVT_GRID_CELL_RCLICK)
+        wx._checkForCallback(self, 'OnLabelLeftClick',       wxEVT_GRID_LABEL_LCLICK)
+        wx._checkForCallback(self, 'OnLabelRightClick',      wxEVT_GRID_LABEL_RCLICK)
+
+
+
+
+class wxGridEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __setattr__(self,name,value):
+        if name == "m_row" :
+            windows2c.wxGridEvent_m_row_set(self.this,value)
+            return
+        if name == "m_col" :
+            windows2c.wxGridEvent_m_col_set(self.this,value)
+            return
+        if name == "m_x" :
+            windows2c.wxGridEvent_m_x_set(self.this,value)
+            return
+        if name == "m_y" :
+            windows2c.wxGridEvent_m_y_set(self.this,value)
+            return
+        if name == "m_control" :
+            windows2c.wxGridEvent_m_control_set(self.this,value)
+            return
+        if name == "m_shift" :
+            windows2c.wxGridEvent_m_shift_set(self.this,value)
+            return
+        if name == "m_cell" :
+            windows2c.wxGridEvent_m_cell_set(self.this,value.this)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_row" : 
+            return windows2c.wxGridEvent_m_row_get(self.this)
+        if name == "m_col" : 
+            return windows2c.wxGridEvent_m_col_get(self.this)
+        if name == "m_x" : 
+            return windows2c.wxGridEvent_m_x_get(self.this)
+        if name == "m_y" : 
+            return windows2c.wxGridEvent_m_y_get(self.this)
+        if name == "m_control" : 
+            return windows2c.wxGridEvent_m_control_get(self.this)
+        if name == "m_shift" : 
+            return windows2c.wxGridEvent_m_shift_get(self.this)
+        if name == "m_cell" : 
+            return wxGridCellPtr(windows2c.wxGridEvent_m_cell_get(self.this))
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxGridEvent instance>"
+class wxGridEvent(wxGridEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxNotebookEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSelection(self):
+        val = windows2c.wxNotebookEvent_GetSelection(self.this)
+        return val
+    def GetOldSelection(self):
+        val = windows2c.wxNotebookEvent_GetOldSelection(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxNotebookEvent instance>"
+class wxNotebookEvent(wxNotebookEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxNotebookPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPageCount(self):
+        val = windows2c.wxNotebook_GetPageCount(self.this)
+        return val
+    def SetSelection(self,arg0):
+        val = windows2c.wxNotebook_SetSelection(self.this,arg0)
+        return val
+    def AdvanceSelection(self,*args):
+        val = apply(windows2c.wxNotebook_AdvanceSelection,(self.this,)+args)
+        return val
+    def GetSelection(self):
+        val = windows2c.wxNotebook_GetSelection(self.this)
+        return val
+    def SetPageText(self,arg0,arg1):
+        val = windows2c.wxNotebook_SetPageText(self.this,arg0,arg1)
+        return val
+    def GetPageText(self,arg0):
+        val = windows2c.wxNotebook_GetPageText(self.this,arg0)
+        return val
+    def SetImageList(self,arg0):
+        val = windows2c.wxNotebook_SetImageList(self.this,arg0)
+        return val
+    def GetImageList(self):
+        val = windows2c.wxNotebook_GetImageList(self.this)
+        return val
+    def GetPageImage(self,arg0):
+        val = windows2c.wxNotebook_GetPageImage(self.this,arg0)
+        return val
+    def SetPageImage(self,arg0,arg1):
+        val = windows2c.wxNotebook_SetPageImage(self.this,arg0,arg1)
+        return val
+    def GetRowCount(self):
+        val = windows2c.wxNotebook_GetRowCount(self.this)
+        return val
+    def DeletePage(self,arg0):
+        val = windows2c.wxNotebook_DeletePage(self.this,arg0)
+        return val
+    def DeleteAllPages(self):
+        val = windows2c.wxNotebook_DeleteAllPages(self.this)
+        return val
+    def AddPage(self,arg0,arg1,*args):
+        val = apply(windows2c.wxNotebook_AddPage,(self.this,arg0.this,arg1,)+args)
+        return val
+    def GetPage(self,arg0):
+        val = windows2c.wxNotebook_GetPage(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxNotebook instance>"
+class wxNotebook(wxNotebookPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows2c.new_wxNotebook,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSplitterWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBorderSize(self):
+        val = windows2c.wxSplitterWindow_GetBorderSize(self.this)
+        return val
+    def GetMinimumPaneSize(self):
+        val = windows2c.wxSplitterWindow_GetMinimumPaneSize(self.this)
+        return val
+    def GetSashPosition(self):
+        val = windows2c.wxSplitterWindow_GetSashPosition(self.this)
+        return val
+    def GetSashSize(self):
+        val = windows2c.wxSplitterWindow_GetSashSize(self.this)
+        return val
+    def GetSplitMode(self):
+        val = windows2c.wxSplitterWindow_GetSplitMode(self.this)
+        return val
+    def GetWindow1(self):
+        val = windows2c.wxSplitterWindow_GetWindow1(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def GetWindow2(self):
+        val = windows2c.wxSplitterWindow_GetWindow2(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def Initialize(self,arg0):
+        val = windows2c.wxSplitterWindow_Initialize(self.this,arg0.this)
+        return val
+    def IsSplit(self):
+        val = windows2c.wxSplitterWindow_IsSplit(self.this)
+        return val
+    def SetBorderSize(self,arg0):
+        val = windows2c.wxSplitterWindow_SetBorderSize(self.this,arg0)
+        return val
+    def SetSashPosition(self,arg0,*args):
+        val = apply(windows2c.wxSplitterWindow_SetSashPosition,(self.this,arg0,)+args)
+        return val
+    def SetSashSize(self,arg0):
+        val = windows2c.wxSplitterWindow_SetSashSize(self.this,arg0)
+        return val
+    def SetMinimumPaneSize(self,arg0):
+        val = windows2c.wxSplitterWindow_SetMinimumPaneSize(self.this,arg0)
+        return val
+    def SetSplitMode(self,arg0):
+        val = windows2c.wxSplitterWindow_SetSplitMode(self.this,arg0)
+        return val
+    def SplitHorizontally(self,arg0,arg1,*args):
+        val = apply(windows2c.wxSplitterWindow_SplitHorizontally,(self.this,arg0.this,arg1.this,)+args)
+        return val
+    def SplitVertically(self,arg0,arg1,*args):
+        val = apply(windows2c.wxSplitterWindow_SplitVertically,(self.this,arg0.this,arg1.this,)+args)
+        return val
+    def Unsplit(self,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windows2c.wxSplitterWindow_Unsplit,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxSplitterWindow instance>"
+class wxSplitterWindow(wxSplitterWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows2c.new_wxSplitterWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxGRID_TEXT_CTRL = windows2c.wxGRID_TEXT_CTRL
+wxGRID_HSCROLL = windows2c.wxGRID_HSCROLL
+wxGRID_VSCROLL = windows2c.wxGRID_VSCROLL
+wxEVT_GRID_SELECT_CELL = windows2c.wxEVT_GRID_SELECT_CELL
+wxEVT_GRID_CREATE_CELL = windows2c.wxEVT_GRID_CREATE_CELL
+wxEVT_GRID_CHANGE_LABELS = windows2c.wxEVT_GRID_CHANGE_LABELS
+wxEVT_GRID_CHANGE_SEL_LABEL = windows2c.wxEVT_GRID_CHANGE_SEL_LABEL
+wxEVT_GRID_CELL_CHANGE = windows2c.wxEVT_GRID_CELL_CHANGE
+wxEVT_GRID_CELL_LCLICK = windows2c.wxEVT_GRID_CELL_LCLICK
+wxEVT_GRID_CELL_RCLICK = windows2c.wxEVT_GRID_CELL_RCLICK
+wxEVT_GRID_LABEL_LCLICK = windows2c.wxEVT_GRID_LABEL_LCLICK
+wxEVT_GRID_LABEL_RCLICK = windows2c.wxEVT_GRID_LABEL_RCLICK

utils/wxPython/src/gtk/windows3.py

@@ -0,0 +1,293 @@
+# This file was created automatically by SWIG.
+import windows3c
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+
+from windows2 import *
+
+from controls import *
+
+from events import *
+
+from mdi import *
+
+from frames import *
+
+from stattool import *
+import wx
+class wxSashEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetEdge(self,arg0):
+        val = windows3c.wxSashEvent_SetEdge(self.this,arg0)
+        return val
+    def GetEdge(self):
+        val = windows3c.wxSashEvent_GetEdge(self.this)
+        return val
+    def SetDragRect(self,arg0):
+        val = windows3c.wxSashEvent_SetDragRect(self.this,arg0.this)
+        return val
+    def GetDragRect(self):
+        val = windows3c.wxSashEvent_GetDragRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def SetDragStatus(self,arg0):
+        val = windows3c.wxSashEvent_SetDragStatus(self.this,arg0)
+        return val
+    def GetDragStatus(self):
+        val = windows3c.wxSashEvent_GetDragStatus(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxSashEvent instance>"
+class wxSashEvent(wxSashEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSashWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSashVisible(self,arg0):
+        val = windows3c.wxSashWindow_GetSashVisible(self.this,arg0)
+        return val
+    def GetDefaultBorderSize(self):
+        val = windows3c.wxSashWindow_GetDefaultBorderSize(self.this)
+        return val
+    def GetEdgeMargin(self,arg0):
+        val = windows3c.wxSashWindow_GetEdgeMargin(self.this,arg0)
+        return val
+    def GetExtraBorderSize(self):
+        val = windows3c.wxSashWindow_GetExtraBorderSize(self.this)
+        return val
+    def GetMaximumSizeX(self):
+        val = windows3c.wxSashWindow_GetMaximumSizeX(self.this)
+        return val
+    def GetMaximumSizeY(self):
+        val = windows3c.wxSashWindow_GetMaximumSizeY(self.this)
+        return val
+    def GetMinimumSizeX(self):
+        val = windows3c.wxSashWindow_GetMinimumSizeX(self.this)
+        return val
+    def GetMinimumSizeY(self):
+        val = windows3c.wxSashWindow_GetMinimumSizeY(self.this)
+        return val
+    def HasBorder(self,arg0):
+        val = windows3c.wxSashWindow_HasBorder(self.this,arg0)
+        return val
+    def SetDefaultBorderSize(self,arg0):
+        val = windows3c.wxSashWindow_SetDefaultBorderSize(self.this,arg0)
+        return val
+    def SetExtraBorderSize(self,arg0):
+        val = windows3c.wxSashWindow_SetExtraBorderSize(self.this,arg0)
+        return val
+    def SetMaximumSizeX(self,arg0):
+        val = windows3c.wxSashWindow_SetMaximumSizeX(self.this,arg0)
+        return val
+    def SetMaximumSizeY(self,arg0):
+        val = windows3c.wxSashWindow_SetMaximumSizeY(self.this,arg0)
+        return val
+    def SetMinimumSizeX(self,arg0):
+        val = windows3c.wxSashWindow_SetMinimumSizeX(self.this,arg0)
+        return val
+    def SetMinimumSizeY(self,arg0):
+        val = windows3c.wxSashWindow_SetMinimumSizeY(self.this,arg0)
+        return val
+    def SetSashVisible(self,arg0,arg1):
+        val = windows3c.wxSashWindow_SetSashVisible(self.this,arg0,arg1)
+        return val
+    def SetSashBorder(self,arg0,arg1):
+        val = windows3c.wxSashWindow_SetSashBorder(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxSashWindow instance>"
+class wxSashWindow(wxSashWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows3c.new_wxSashWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxQueryLayoutInfoEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetRequestedLength(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetRequestedLength(self.this,arg0)
+        return val
+    def GetRequestedLength(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetRequestedLength(self.this)
+        return val
+    def SetFlags(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetFlags(self.this,arg0)
+        return val
+    def GetFlags(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetFlags(self.this)
+        return val
+    def SetSize(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetSize(self.this,arg0.this)
+        return val
+    def GetSize(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def SetOrientation(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetOrientation(self.this,arg0)
+        return val
+    def GetOrientation(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetOrientation(self.this)
+        return val
+    def SetAlignment(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetAlignment(self.this,arg0)
+        return val
+    def GetAlignment(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetAlignment(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxQueryLayoutInfoEvent instance>"
+class wxQueryLayoutInfoEvent(wxQueryLayoutInfoEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCalculateLayoutEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetFlags(self,arg0):
+        val = windows3c.wxCalculateLayoutEvent_SetFlags(self.this,arg0)
+        return val
+    def GetFlags(self):
+        val = windows3c.wxCalculateLayoutEvent_GetFlags(self.this)
+        return val
+    def SetRect(self,arg0):
+        val = windows3c.wxCalculateLayoutEvent_SetRect(self.this,arg0.this)
+        return val
+    def GetRect(self):
+        val = windows3c.wxCalculateLayoutEvent_GetRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxCalculateLayoutEvent instance>"
+class wxCalculateLayoutEvent(wxCalculateLayoutEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSashLayoutWindowPtr(wxSashWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetAlignment(self):
+        val = windows3c.wxSashLayoutWindow_GetAlignment(self.this)
+        return val
+    def GetOrientation(self):
+        val = windows3c.wxSashLayoutWindow_GetOrientation(self.this)
+        return val
+    def SetAlignment(self,arg0):
+        val = windows3c.wxSashLayoutWindow_SetAlignment(self.this,arg0)
+        return val
+    def SetDefaultSize(self,arg0):
+        val = windows3c.wxSashLayoutWindow_SetDefaultSize(self.this,arg0.this)
+        return val
+    def SetOrientation(self,arg0):
+        val = windows3c.wxSashLayoutWindow_SetOrientation(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSashLayoutWindow instance>"
+class wxSashLayoutWindow(wxSashLayoutWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows3c.new_wxSashLayoutWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._checkForCallback(self, 'OnCalculateLayout',    wxEVT_CALCULATE_LAYOUT)
+        wx._checkForCallback(self, 'OnQueryLayoutInfo',    wxEVT_QUERY_LAYOUT_INFO)
+
+
+
+
+class wxLayoutAlgorithmPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            windows3c.delete_wxLayoutAlgorithm(self.this)
+    def LayoutMDIFrame(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windows3c.wxLayoutAlgorithm_LayoutMDIFrame,(self.this,arg0.this,)+args)
+        return val
+    def LayoutFrame(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windows3c.wxLayoutAlgorithm_LayoutFrame,(self.this,arg0.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxLayoutAlgorithm instance>"
+class wxLayoutAlgorithm(wxLayoutAlgorithmPtr):
+    def __init__(self) :
+        self.this = windows3c.new_wxLayoutAlgorithm()
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxSASH_TOP = windows3c.wxSASH_TOP
+wxSASH_RIGHT = windows3c.wxSASH_RIGHT
+wxSASH_BOTTOM = windows3c.wxSASH_BOTTOM
+wxSASH_LEFT = windows3c.wxSASH_LEFT
+wxSASH_NONE = windows3c.wxSASH_NONE
+wxEVT_SASH_DRAGGED = windows3c.wxEVT_SASH_DRAGGED
+wxSW_3D = windows3c.wxSW_3D
+wxSASH_STATUS_OK = windows3c.wxSASH_STATUS_OK
+wxSASH_STATUS_OUT_OF_RANGE = windows3c.wxSASH_STATUS_OUT_OF_RANGE
+wxLAYOUT_HORIZONTAL = windows3c.wxLAYOUT_HORIZONTAL
+wxLAYOUT_VERTICAL = windows3c.wxLAYOUT_VERTICAL
+wxLAYOUT_NONE = windows3c.wxLAYOUT_NONE
+wxLAYOUT_TOP = windows3c.wxLAYOUT_TOP
+wxLAYOUT_LEFT = windows3c.wxLAYOUT_LEFT
+wxLAYOUT_RIGHT = windows3c.wxLAYOUT_RIGHT
+wxLAYOUT_BOTTOM = windows3c.wxLAYOUT_BOTTOM
+wxEVT_QUERY_LAYOUT_INFO = windows3c.wxEVT_QUERY_LAYOUT_INFO
+wxEVT_CALCULATE_LAYOUT = windows3c.wxEVT_CALCULATE_LAYOUT

utils/wxPython/src/helpers.cpp

@@ -0,0 +1,680 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpers.cpp
+// Purpose:     Helper functions/classes for the wxPython extension module
+//
+// Author:      Robin Dunn
+//
+// Created:     7/1/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __WXMSW__
+#include <windows.h>
+#undef FindWindow
+#undef GetCharWidth
+#undef LoadAccelerators
+#endif
+
+#ifdef __WXGTK__
+#include "gtk/gtk.h"
+#endif
+
+#undef DEBUG
+#include <Python.h>
+#include "helpers.h"
+#include <wx/module.h>
+
+//---------------------------------------------------------------------------
+
+//wxHashTable*  wxPyWindows = NULL;
+
+
+wxPoint     wxPyDefaultPosition;        //wxDefaultPosition);
+wxSize      wxPyDefaultSize;            //wxDefaultSize);
+wxString    wxPyEmptyStr("");
+
+
+
+#ifdef __WXMSW__             // If building for win32...
+extern HINSTANCE wxhInstance;
+
+//----------------------------------------------------------------------
+// This gets run when the DLL is loaded.  We just need to save a handle.
+//----------------------------------------------------------------------
+
+BOOL WINAPI DllMain(
+    HINSTANCE   hinstDLL,    // handle to DLL module
+    DWORD       fdwReason,   // reason for calling function
+    LPVOID      lpvReserved  // reserved
+   )
+{
+    wxhInstance = hinstDLL;
+    return 1;
+}
+#endif
+
+//----------------------------------------------------------------------
+// Class for implementing the wxp main application shell.
+//----------------------------------------------------------------------
+
+wxPyApp *wxPythonApp = NULL;            // Global instance of application object
+
+
+// This one isn't acutally called...  See __wxStart()
+bool wxPyApp::OnInit(void) {
+    return false;
+}
+
+int  wxPyApp::MainLoop(void) {
+    int retval = wxApp::MainLoop();
+    AfterMainLoop();
+    return retval;
+}
+
+void wxPyApp::AfterMainLoop(void) {
+    // more stuff from wxEntry...
+
+    if (wxPythonApp->GetTopWindow()) {
+        // Forcibly delete the window.
+        if (wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxFrame)) ||
+            wxPythonApp->GetTopWindow()->IsKindOf(CLASSINFO(wxDialog))) {
+
+            wxPythonApp->GetTopWindow()->Close(TRUE);
+            wxPythonApp->DeletePendingObjects();
+        }
+        else {
+            delete wxPythonApp->GetTopWindow();
+            wxPythonApp->SetTopWindow(NULL);
+        }
+    }
+#ifdef __WXGTK__
+      wxPythonApp->DeletePendingObjects();
+#endif
+
+    wxPythonApp->OnExit();
+    wxApp::CleanUp();
+//    delete wxPythonApp;
+}
+
+
+//---------------------------------------------------------------------
+// a few native methods to add to the module
+//----------------------------------------------------------------------
+
+
+// This is where we pick up the first part of the wxEntry functionality...
+// The rest is in __wxStart and  AfterMainLoop.  This function is called when
+// wxpc is imported.  (Before there is a wxApp object.)
+void __wxPreStart()
+{
+    // Bail out if there is already windows created.  This means that the
+    // toolkit has already been initialized, as in embedding wxPython in
+    // a C++ wxWindows app.
+    if (wxTopLevelWindows.Number() > 0)
+        return;
+
+#ifdef __WXMSW__
+    wxApp::Initialize();
+#endif
+
+#ifdef __WXGTK__
+    PyObject* sysargv = PySys_GetObject("argv");
+    int argc = PyList_Size(sysargv);
+    char** argv = new char*[argc+1];
+    int x;
+    for(x=0; x<argc; x++)
+        argv[x] = PyString_AsString(PyList_GetItem(sysargv, x));
+    argv[argc] = NULL;
+
+    gtk_set_locale();
+    gtk_init( &argc, &argv );
+    delete [] argv;
+
+    wxApp::Initialize();     // may return FALSE. Should we check?
+#endif
+
+}
+
+
+
+static char* __nullArgv[1] = { 0 };
+
+// Start the user application, user App's OnInit method is a parameter here
+PyObject* __wxStart(PyObject* /* self */, PyObject* args)
+{
+    PyObject*   onInitFunc = NULL;
+    PyObject*   arglist;
+    PyObject*   result;
+    long        bResult;
+
+
+    if (!PyArg_ParseTuple(args, "O", &onInitFunc))
+        return NULL;
+
+    if (wxTopLevelWindows.Number() > 0) {
+        PyErr_SetString(PyExc_TypeError, "Only 1 wxApp per process!");
+        return NULL;
+    }
+
+
+    // This is the next part of the wxEntry functionality...
+    wxPythonApp->argc = 0;
+    wxPythonApp->argv = __nullArgv;
+    wxPythonApp->OnInitGui();
+
+
+    // Call the Python App's OnInit function
+    arglist = PyTuple_New(0);
+    result = PyEval_CallObject(onInitFunc, arglist);
+    if (!result) {
+        PyErr_Print();
+        exit(1);
+    }
+
+    if (! PyInt_Check(result)) {
+        PyErr_SetString(PyExc_TypeError, "OnInit should return a boolean value");
+        return NULL;
+    }
+    bResult = PyInt_AS_LONG(result);
+    if (! bResult) {
+        wxPythonApp->DeletePendingObjects();
+        wxPythonApp->OnExit();
+        wxApp::CleanUp();
+        PyErr_SetString(PyExc_SystemExit, "OnInit returned false, exiting...");
+        return NULL;
+    }
+
+#ifdef __WXGTK__
+    wxTheApp->m_initialized = (wxTopLevelWindows.Number() > 0);
+#endif
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+
+
+
+PyObject* wxPython_dict;
+PyObject* __wxSetDictionary(PyObject* /* self */, PyObject* args)
+{
+
+    if (!PyArg_ParseTuple(args, "O", &wxPython_dict))
+        return NULL;
+
+    if (!PyDict_Check(wxPython_dict)) {
+        PyErr_SetString(PyExc_TypeError, "_wxSetDictionary must have dictionary object!");
+        return NULL;
+    }
+#ifdef __WXMOTIF__
+#define wxPlatform "__WXMOTIF__"
+#endif
+#ifdef __WXQT__
+#define wxPlatform "__WXQT__"
+#endif
+#ifdef __WXGTK__
+#define wxPlatform "__WXGTK__"
+#endif
+#if defined(__WIN32__) || defined(__WXMSW__)
+#define wxPlatform "__WXMSW__"
+#endif
+#ifdef __WXMAC__
+#define wxPlatform "__WXMAC__"
+#endif
+
+    PyDict_SetItemString(wxPython_dict, "wxPlatform", PyString_FromString(wxPlatform));
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+//---------------------------------------------------------------------------
+
+
+static
+PyObject* wxPyConstructObject(void* ptr, char* className)
+{
+    char    buff[64];               // should always be big enough...
+    char    swigptr[64];
+
+    sprintf(buff, "_%s_p", className);
+    SWIG_MakePtr(swigptr, ptr, buff);
+
+    sprintf(buff, "%sPtr", className);
+    PyObject* classobj = PyDict_GetItemString(wxPython_dict, buff);
+    if (! classobj) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    PyObject* arg = Py_BuildValue("(s)", swigptr);
+    PyObject* obj = PyInstance_New(classobj, arg, NULL);
+    Py_DECREF(arg);
+
+    return obj;
+}
+
+
+// This function is used for all events destined for Python event handlers.
+void wxPyCallback::EventThunker(wxEvent& event) {
+    wxPyCallback*   cb = (wxPyCallback*)event.m_callbackUserData;
+    PyObject*       func = cb->m_func;
+    PyObject*       result;
+    PyObject*       arg;
+    PyObject*       tuple;
+
+    arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName());
+
+    tuple = PyTuple_New(1);
+    PyTuple_SET_ITEM(tuple, 0, arg);
+    result = PyEval_CallObject(func, tuple);
+    Py_DECREF(tuple);
+    if (result) {
+        Py_DECREF(result);
+        PyErr_Clear();
+    } else {
+        PyErr_Print();
+    }
+}
+
+
+//---------------------------------------------------------------------------
+
+wxPyMenu::wxPyMenu(const wxString& title, PyObject* _func)
+    : wxMenu(title, (wxFunction)(func ? MenuCallback : NULL)), func(0) {
+
+    if (_func) {
+        func = _func;
+        Py_INCREF(func);
+    }
+}
+
+wxPyMenu::~wxPyMenu() {
+    if (func)
+        Py_DECREF(func);
+}
+
+
+void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) {
+    PyObject* evtobj  = wxPyConstructObject((void*)&evt, "wxCommandEvent");
+    PyObject* menuobj = wxPyConstructObject((void*)&menu, "wxMenu");
+    if (PyErr_Occurred()) {
+        // bail out if a problem
+        PyErr_Print();
+        return;
+    }
+    // Now call the callback...
+    PyObject* func = ((wxPyMenu*)&menu)->func;
+    PyObject* args = PyTuple_New(2);
+    PyTuple_SET_ITEM(args, 0, menuobj);
+    PyTuple_SET_ITEM(args, 1, evtobj);
+    PyObject* res  = PyEval_CallObject(func, args);
+    Py_DECREF(args);
+    Py_XDECREF(res); /* In case res is a NULL pointer */
+}
+
+
+//---------------------------------------------------------------------------
+
+wxPyTimer::wxPyTimer(PyObject* callback) {
+    func = callback;
+    Py_INCREF(func);
+}
+
+wxPyTimer::~wxPyTimer() {
+    Py_DECREF(func);
+}
+
+void wxPyTimer::Notify() {
+    PyObject*   result;
+    PyObject*   args = Py_BuildValue("()");
+
+    result = PyEval_CallObject(func, args);
+    Py_DECREF(args);
+    if (result) {
+        Py_DECREF(result);
+        PyErr_Clear();
+    } else {
+        PyErr_Print();
+    }
+}
+
+
+
+//----------------------------------------------------------------------
+//----------------------------------------------------------------------
+// Some helper functions for typemaps in my_typemaps.i, so they won't be
+// imcluded in every file...
+
+
+byte* byte_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count = PyList_Size(source);
+    byte* temp = new byte[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (! PyInt_Check(o)) {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
+            return NULL;
+        }
+        temp[x] = (byte)PyInt_AsLong(o);
+    }
+    return temp;
+}
+
+
+int* int_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count = PyList_Size(source);
+    int* temp = new int[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (! PyInt_Check(o)) {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
+            return NULL;
+        }
+        temp[x] = PyInt_AsLong(o);
+    }
+    return temp;
+}
+
+
+long* long_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count = PyList_Size(source);
+    long* temp = new long[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (! PyInt_Check(o)) {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of integers.");
+            return NULL;
+        }
+        temp[x] = PyInt_AsLong(o);
+    }
+    return temp;
+}
+
+
+char** string_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count = PyList_Size(source);
+    char** temp = new char*[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (! PyString_Check(o)) {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
+            return NULL;
+        }
+        temp[x] = PyString_AsString(o);
+    }
+    return temp;
+}
+
+
+
+wxPoint* wxPoint_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count = PyList_Size(source);
+    wxPoint* temp = new wxPoint[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (PyString_Check(o)) {
+            char*       st = PyString_AsString(o);
+            wxPoint*    pt;
+            if (SWIG_GetPtr(st,(void **) &pt,"_wxPoint_p")) {
+                PyErr_SetString(PyExc_TypeError,"Expected _wxPoint_p.");
+                return NULL;
+            }
+            temp[x] = *pt;
+        }
+        else if (PyTuple_Check(o)) {
+            PyObject* o1 = PyTuple_GetItem(o, 0);
+            PyObject* o2 = PyTuple_GetItem(o, 1);
+
+            temp[x].x = PyInt_AsLong(o1);
+            temp[x].y = PyInt_AsLong(o2);
+        }
+        else {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of 2-tuples or wxPoints.");
+            return NULL;
+        }
+    }
+    return temp;
+}
+
+
+wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count = PyList_Size(source);
+    wxBitmap** temp = new wxBitmap*[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (PyString_Check(o)) {
+            char*       st = PyString_AsString(o);
+            wxBitmap*    pt;
+            if (SWIG_GetPtr(st,(void **) &pt,"_wxBitmap_p")) {
+                PyErr_SetString(PyExc_TypeError,"Expected _wxBitmap_p.");
+                return NULL;
+            }
+            temp[x] = pt;
+        }
+        else {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of wxBitmaps.");
+            return NULL;
+        }
+    }
+    return temp;
+}
+
+
+
+wxString* wxString_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count = PyList_Size(source);
+    wxString* temp = new wxString[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (! PyString_Check(o)) {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
+            return NULL;
+        }
+        temp[x] = PyString_AsString(o);
+    }
+    return temp;
+}
+
+
+wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
+    if (!PyList_Check(source)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
+        return NULL;
+    }
+    int count                = PyList_Size(source);
+    wxAcceleratorEntry* temp = new wxAcceleratorEntry[count];
+    if (! temp) {
+        PyErr_SetString(PyExc_MemoryError, "Unable to allocate temporary array");
+        return NULL;
+    }
+    for (int x=0; x<count; x++) {
+        PyObject* o = PyList_GetItem(source, x);
+        if (PyString_Check(o)) {
+            char*               st = PyString_AsString(o);
+            wxAcceleratorEntry* ae;
+            if (SWIG_GetPtr(st,(void **) &ae,"_wxAcceleratorEntry_p")) {
+                PyErr_SetString(PyExc_TypeError,"Expected _wxAcceleratorEntry_p.");
+                return NULL;
+            }
+            temp[x] = *ae;
+        }
+        else if (PyTuple_Check(o)) {
+            PyObject* o1 = PyTuple_GetItem(o, 0);
+            PyObject* o2 = PyTuple_GetItem(o, 1);
+            PyObject* o3 = PyTuple_GetItem(o, 2);
+
+            temp[x].m_flags   = PyInt_AsLong(o1);
+            temp[x].m_keyCode = PyInt_AsLong(o2);
+            temp[x].m_command = PyInt_AsLong(o3);
+        }
+        else {
+            PyErr_SetString(PyExc_TypeError, "Expected a list of 3-tuples or wxAcceleratorEntry objects.");
+            return NULL;
+        }
+    }
+    return temp;
+}
+
+//----------------------------------------------------------------------
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.18  1999/01/30 08:17:27  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.17  1999/01/30 07:30:12  RD
+//
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.16  1998/12/17 14:07:39  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.15  1998/12/15 20:41:19  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.14  1998/11/25 08:45:25  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.13  1998/11/15 23:03:45  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.12  1998/11/03 09:21:08  RD
+// fixed a typo
+//
+// Revision 1.11  1998/10/20 06:43:58  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.10  1998/10/02 06:40:39  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.9  1998/09/25 13:28:52  VZ
+//
+// USE_xxx constants renamed to wxUSE_xxx. This is an incompatible change, you
+// must recompile everything after upgrading!
+//
+// Revision 1.8  1998/08/27 21:59:08  RD
+// Some chicken-and-egg problems solved for wxPython on wxGTK
+//
+// Revision 1.7  1998/08/27 00:00:26  RD
+// - more tweaks
+// - have discovered some problems but not yet discovered solutions...
+//
+// Revision 1.6  1998/08/18 21:54:12  RD
+//
+// ifdef out some wxGTK specific code
+//
+// Revision 1.5  1998/08/18 19:48:17  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.4  1998/08/16 04:31:06  RD
+// More wxGTK work.
+//
+// Revision 1.3  1998/08/15 07:36:36  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.2  1998/08/14 23:36:36  RD
+// Beginings of wxGTK compatibility
+//
+// Revision 1.1  1998/08/09 08:25:51  RD
+// Initial version
+//
+//

utils/wxPython/src/helpers.h

@@ -0,0 +1,131 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpers.h
+// Purpose:     Helper functions/classes for the wxPython extenaion module
+//
+// Author:      Robin Dunn
+//
+// Created:     7/1/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __wxp_helpers__
+#define __wxp_helpers__
+
+#include <wx/wx.h>
+
+
+//----------------------------------------------------------------------
+
+class wxPyApp: public wxApp
+{
+public:
+    int  MainLoop(void);
+    bool OnInit(void);
+    void AfterMainLoop(void);
+};
+
+extern wxPyApp *wxPythonApp;
+
+//----------------------------------------------------------------------
+
+void      __wxPreStart();
+PyObject* __wxStart(PyObject*, PyObject* args);
+
+extern PyObject* wxPython_dict;
+PyObject* __wxSetDictionary(PyObject*, PyObject* args);
+
+extern wxHashTable*  wxPyWindows;  // keep track of all windows so we
+                                   // don't accidentally delete them twice.
+
+void wxPyEventThunker(wxObject*, wxEvent& event);
+
+//----------------------------------------------------------------------
+
+
+#ifndef SWIGCODE
+extern "C" void SWIG_MakePtr(char *, void *, char *);
+extern "C" char *SWIG_GetPtr(char *, void **, char *);
+#endif
+
+
+#ifdef _MSC_VER
+# pragma warning(disable:4800)
+#endif
+
+typedef unsigned char byte;
+
+
+// Non-const versions to keep SWIG happy.
+extern wxPoint  wxPyDefaultPosition;
+extern wxSize   wxPyDefaultSize;
+extern wxString wxPyEmptyStr;
+
+//----------------------------------------------------------------------
+
+class wxPyCallback : public wxObject {
+public:
+    wxPyCallback(PyObject* func)    { m_func = func; Py_INCREF(m_func); }
+    ~wxPyCallback()                 { Py_DECREF(m_func); }
+
+    void EventThunker(wxEvent& event);
+
+    PyObject*   m_func;
+};
+
+//---------------------------------------------------------------------------
+
+class wxPyMenu : public wxMenu {
+public:
+    wxPyMenu(const wxString& title = "", PyObject* func=NULL);
+    ~wxPyMenu();
+
+private:
+    static void MenuCallback(wxMenu& menu, wxCommandEvent& evt);
+    PyObject*   func;
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxPyTimer : public wxTimer {
+public:
+    wxPyTimer(PyObject* callback);
+    ~wxPyTimer();
+
+    void        Notify();
+
+private:
+    PyObject*   func;
+};
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.6  1998/11/25 08:45:26  RD
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.5  1998/10/02 06:40:40  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.4  1998/08/27 21:59:09  RD
+// Some chicken-and-egg problems solved for wxPython on wxGTK
+//
+// Revision 1.3  1998/08/16 04:31:09  RD
+// More wxGTK work.
+//
+// Revision 1.2  1998/08/14 23:36:37  RD
+// Beginings of wxGTK compatibility
+//
+// Revision 1.1  1998/08/09 08:25:51  RD
+// Initial version
+//
+//
+
+#endif
+

utils/wxPython/src/makefile.nt

@@ -0,0 +1,328 @@
+#----------------------------------------------------------------------------
+# Name:		makefile.nt
+# Purpose:	Win32, VC++ 5 makefile for wxPython
+#
+# Author:       Robin Dunn
+#
+# Created:	3/27/97
+# RCS-ID:       $Id$
+# Copyright:    (c) 1998 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+VERSION=0.5.4
+
+# Set WXDIR to the root wxWindows directory for your system
+WXDIR = $(WXWIN)
+
+# Set this to the root of the Python installation
+PYTHONDIR=e:\Tools\Python15
+
+# Set this to 1 for a non-debug, optimised compile
+FINAL=0
+
+# Set this to where you want the stuff installed at.  It should
+# be a directory contained in a PYTHONPATH directory, and should be
+# named wxPython
+TARGETDIR=..
+
+# Set this to 1 for make to pre-compile the Python modules, 0 to
+# just copy the sources and let Python compile them at the first
+# runtime.
+COMPILEPY=0
+
+SEPARATE=0
+
+#----------------------------------------------------------------------
+
+WXUSINGDLL=0
+NOPCH=1
+THISDIR=$(WXDIR)\utils\wxPython
+
+EXTRALIBS=$(PYTHONDIR)\libs\python15.lib
+EXTRAINC=-I$(PYTHONDIR)\include -I.
+EXTRAFLAGS=/Fpwxp.pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H
+OVERRIDEFLAGS=/GX-
+
+
+SWIGFLAGS=-c++ -shadow -python -dnone -D__WXMSW__
+GENCODEDIR=msw
+
+
+!include $(WXDIR)\src\ntwxwin.mak
+
+#----------------------------------------------------------------------
+
+TARGET = wxc
+
+OBJECTS = wx.obj         helpers.obj    windows.obj    events.obj     \
+	  misc.obj       gdi.obj        mdi.obj        controls.obj   \
+	  controls2.obj  windows2.obj   cmndlgs.obj    stattool.obj   \
+	  frames.obj     windows3.obj \
+!if "$(SEPARATE)" == "0"
+	  utils.obj
+!else
+
+TARGET2 = utilsc
+OBJECTS2 = utils.obj
+target2=$(TARGETDIR)\$(TARGET2).pyd
+!endif
+
+PYMODULES = $(TARGETDIR)\wx.py        $(TARGETDIR)\events.py    \
+	    $(TARGETDIR)\windows.py   $(TARGETDIR)\misc.py      \
+	    $(TARGETDIR)\gdi.py       $(TARGETDIR)\mdi.py       \
+	    $(TARGETDIR)\controls.py  $(TARGETDIR)\controls2.py \
+            $(TARGETDIR)\windows2.py  $(TARGETDIR)\cmndlgs.py   \
+	    $(TARGETDIR)\stattool.py  $(TARGETDIR)\frames.py    \
+	    $(TARGETDIR)\utils.py     $(TARGETDIR)\windows3.py  \
+	    $(TARGETDIR)\__init__.py
+
+
+#----------------------------------------------------------------------
+
+!if "$(FINAL)" == "0"
+DEBUGLFLAGS = /DEBUG /INCREMENTAL:YES
+!else
+DEBUGLFLAGS = /INCREMENTAL:NO
+!endif
+
+LFLAGS= $(DEBUGLFLAGS) /DLL /def:$(TARGET).def /subsystem:windows,3.50 \
+	/machine:I386 /implib:./$(TARGET).lib /nologo
+
+LFLAGS2=$(DEBUGLFLAGS) /DLL /def:$(TARGET2).def /subsystem:windows,3.50 \
+	/machine:I386 /implib:./$(TARGET2).lib /nologo
+
+#----------------------------------------------------------------------
+
+default: $(TARGETDIR)\$(TARGET).pyd $(target2) pycfiles
+
+all:	wx $(TARGET) $(TARGET2)
+
+wx:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.nt FINAL=$(FINAL)
+        cd $(THISDIR)
+
+wxclean:
+        cd $(WXDIR)\src\msw
+        nmake -f makefile.nt clean
+        cd $(THISDIR)
+
+
+pycfiles : $(PYMODULES)
+!if "$(COMPILEPY)" == "1"
+	$(PYTHONDIR)\python $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
+	$(PYTHONDIR)\python -O $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
+!endif
+
+#----------------------------------------------------------------------
+
+$(TARGETDIR)\$(TARGET).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(TARGET).res
+	$(link) @<<
+/out:$@ /dll
+$(LFLAGS)
+$(DUMMYOBJ) $(OBJECTS) $(TARGET).res
+$(LIBS)
+<<
+
+$(TARGETDIR)\$(TARGET2).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS2)
+	$(link) @<<
+/out:$@ /dll
+$(LFLAGS2)
+$(DUMMYOBJ) $(OBJECTS2)
+$(LIBS)
+<<
+
+
+$(TARGET).res :      $(TARGET).rc $(WXDIR)\include\wx\msw\wx.rc
+    $(rc) -r /i$(WXDIR)\include -fo$@ $(TARGET).rc
+
+
+
+# implicit rule for compiling .cpp files
+{}.cpp{}.obj:
+        $(cc) @<<
+$(CPPFLAGS) /c /Tp $<
+<<
+
+{$(GENCODEDIR)}.cpp{}.obj:
+        $(cc) @<<
+$(CPPFLAGS) /c /Tp $<
+<<
+
+
+clean:
+        -erase *.obj
+        -erase *.exe
+        -erase *.res
+        -erase *.map
+        -erase *.sbr
+        -erase *.pdb
+	-erase *.pch
+	-erase $(TARGET).exp
+	-erase $(TARGET).lib
+	-erase $(TARGETDIR)\$(TARGET).*
+!if "$(SEPARATE)" != "0"
+	-erase $(TARGET2).exp
+	-erase $(TARGET2).lib
+	-erase $(TARGETDIR)\$(TARGET2).*
+!endif
+	-erase $(TARGETDIR)\$(TARGET).pyd
+	-erase $(TARGETDIR)\*.py
+	-erase $(TARGETDIR)\*.pyc
+	-erase $(TARGETDIR)\*.pyo
+
+
+
+#------------------------------------------------------------------------
+
+.SUFFIXES : .i .py
+
+# Implicit rules to run SWIG
+{}.i{$(GENCODEDIR)}.cpp:
+	swig $(SWIGFLAGS) -c -o $@ $<
+
+{}.i{$(GENCODEDIR)}.py:
+	swig $(SWIGFLAGS) -c -o $@ $<
+
+
+{$(GENCODEDIR)}.py{$(TARGETDIR)}.py:
+	copy $< $@
+
+{}.py{$(TARGETDIR)}.py:
+	copy $< $@
+
+#{}.py{$(TARGETDIR)}.$(PYEXT):
+#	$(PYTHON) -c "import py_compile; py_compile.compile('$<', '$@')"
+
+
+
+
+# This one must leave out the -c flag so we define the whole rule
+$(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py : wx.i my_typemaps.i _defs.i _extras.py
+        swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
+
+
+# Define some dependencies.  These MUST use forward slashes so SWIG
+# will write the shadow file to the right directory.
+$(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py   : windows.i    my_typemaps.i _defs.i
+$(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py  : windows2.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py  : windows3.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py    : events.i     my_typemaps.i _defs.i
+$(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py      : misc.i       my_typemaps.i _defs.i
+$(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py       : gdi.i        my_typemaps.i _defs.i
+$(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py       : mdi.i        my_typemaps.i _defs.i
+$(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py  : controls.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i  my_typemaps.i _defs.i
+$(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py   : cmndlgs.i    my_typemaps.i _defs.i
+$(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py  : stattool.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py    : frames.i     my_typemaps.i _defs.i
+
+!if "$(SEPARATE)" == "1"
+$(GENCODEDIR)\utils.cpp $(GENCODEDIR)\utils.py : utils.i my_typemaps.i
+        swig $(SWIGFLAGS) -o $(GENCODEDIR)/utils.cpp utils.i
+!else
+$(GENCODEDIR)/utils.cpp    $(GENCODEDIR)/utils.py    : utils.i     my_typemaps.i _defs.i
+!endif
+
+
+$(TARGETDIR)\wx.py        : $(GENCODEDIR)\wx.py
+$(TARGETDIR)\windows.py   : $(GENCODEDIR)\windows.py
+$(TARGETDIR)\windows2.py  : $(GENCODEDIR)\windows2.py
+$(TARGETDIR)\windows3.py  : $(GENCODEDIR)\windows3.py
+$(TARGETDIR)\events.py    : $(GENCODEDIR)\events.py
+$(TARGETDIR)\misc.py      : $(GENCODEDIR)\misc.py
+$(TARGETDIR)\gdi.py       : $(GENCODEDIR)\gdi.py
+$(TARGETDIR)\mdi.py       : $(GENCODEDIR)\mdi.py
+$(TARGETDIR)\controls.py  : $(GENCODEDIR)\controls.py
+$(TARGETDIR)\controls2.py : $(GENCODEDIR)\controls2.py
+$(TARGETDIR)\cmndlgs.py   : $(GENCODEDIR)\cmndlgs.py
+$(TARGETDIR)\frames.py    : $(GENCODEDIR)\frames.py
+$(TARGETDIR)\stattool.py  : $(GENCODEDIR)\stattool.py
+$(TARGETDIR)\utils.py     : $(GENCODEDIR)\utils.py
+$(TARGETDIR)\__init__.py  : __init__.py
+
+
+SOURCES = $(GENCODEDIR)\wx.cpp        $(GENCODEDIR)\wx.py       \
+	  $(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py  \
+	  $(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py \
+	  $(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py \
+	  $(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py   \
+	  $(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py     \
+	  $(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py      \
+	  $(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py      \
+	  $(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py \
+	  $(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py\
+	  $(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py  \
+	  $(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py \
+	  $(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py   \
+	  $(GENCODEDIR)/utils.cpp     $(GENCODEDIR)/utils.py    \
+
+
+sources : $(SOURCES)
+
+
+dist:
+	cd ..\..
+	wxPython\distrib\zipit.bat $(VERSION)
+
+#------------------------------------------------------------------------
+#
+# $Log$
+# Revision 1.10  1999/02/01 00:10:40  RD
+# Added the missing EVT_LIST_ITEM_SELECTED and friends.
+#
+# Revision 1.9  1999/01/30 07:30:13  RD
+#
+# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+#
+# Various cleanup, tweaks, minor additions, etc. to maintain
+# compatibility with the current wxWindows.
+#
+# Revision 1.8  1998/12/21 19:58:06  RD
+#
+# Now compiles with /GX- on MSW.
+#
+# Revision 1.7  1998/12/15 20:41:20  RD
+# Changed the import semantics from "from wxPython import *" to "from
+# wxPython.wx import *"  This is for people who are worried about
+# namespace pollution, they can use "from wxPython import wx" and then
+# prefix all the wxPython identifiers with "wx."
+#
+# Added wxTaskbarIcon for wxMSW.
+#
+# Made the events work for wxGrid.
+#
+# Added wxConfig.
+#
+# Added wxMiniFrame for wxGTK, (untested.)
+#
+# Changed many of the args and return values that were pointers to gdi
+# objects to references to reflect changes in the wxWindows API.
+#
+# Other assorted fixes and additions.
+#
+# Revision 1.6  1998/10/02 06:40:41  RD
+#
+# Version 0.4 of wxPython for MSW.
+#
+# Revision 1.5  1998/08/19 00:38:23  RD
+#
+# A few tweaks
+#
+# Revision 1.4  1998/08/18 21:55:10  RD
+#
+# New build directory structure
+#
+# Revision 1.3  1998/08/15 07:36:37  RD
+# - Moved the header in the .i files out of the code that gets put into
+# the .cpp files.  It caused CVS conflicts because of the RCS ID being
+# different each time.
+#
+# - A few minor fixes.
+#
+# Revision 1.2  1998/08/14 03:34:23  RD
+# made pre-compiling the python files optional
+#
+# Revision 1.1  1998/08/09 08:25:51  RD
+# Initial version
+#

utils/wxPython/src/mdi.i

@@ -0,0 +1,141 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        mdi.i
+// Purpose:     MDI related class definitions for wxPython
+//
+// Author:      Robin Dunn
+//
+// Created:     5/26/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module mdi
+
+%{
+#include "helpers.h"
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import windows.i
+%import frames.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+class wxMDIParentFrame : public wxFrame {
+public:
+    wxMDIParentFrame(wxWindow *parent,
+                     const wxWindowID id,
+                     const wxString& title,
+                     const wxPoint& pos = wxPyDefaultPosition,
+                     const wxSize& size = wxPyDefaultSize,
+                     long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
+                     const char* name = "frame");
+
+    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
+
+    void ActivateNext();
+    void ActivatePrevious();
+    void ArrangeIcons();
+    void Cascade();
+    void GetClientSize(int* OUTPUT, int* OUTPUT);
+    wxMDIChildFrame* GetActiveChild();
+    wxMDIClientWindow* GetClientWindow();
+    wxWindow* GetToolBar();
+
+    // TODO:  This isn't handled by the standard event-table system...
+    //wxMDIClientWindow* OnCreateClient();
+
+#ifdef __WXMSW__
+    void SetToolBar(wxToolBar* toolbar);
+#endif
+    void Tile();
+};
+
+//---------------------------------------------------------------------------
+
+class wxMDIChildFrame : public wxFrame {
+public:
+    wxMDIChildFrame(wxMDIParentFrame* parent,
+                    const wxWindowID id,
+                    const wxString& title,
+                    const wxPoint& pos = wxPyDefaultPosition,
+                    const wxSize& size = wxPyDefaultSize,
+                    long style = wxDEFAULT_FRAME_STYLE,
+                    const char* name = "frame");
+
+    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
+
+    void Activate();
+    void Maximize();
+    void Restore();
+
+    void SetMenuBar(wxMenuBar *menu_bar);
+    void SetClientSize(int width, int height);
+    void GetPosition(int* OUTPUT, int* OUTPUT) const ;
+
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxMDIClientWindow : public wxWindow {
+public:
+    wxMDIClientWindow(wxMDIParentFrame* parent, long style = 0);
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+    %pragma(python) addtomethod = "__init__:wx._StdOnScrollCallbacks(self)"
+};
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.5  1998/12/15 20:41:21  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.4  1998/10/02 06:40:41  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:18  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:39  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:51  RD
+// Initial version
+//
+//

utils/wxPython/src/misc.i

@@ -0,0 +1,426 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        misc.i
+// Purpose:     Definitions of miscelaneous functions and classes
+//
+// Author:      Robin Dunn
+//
+// Created:     7/3/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module misc
+
+%{
+#include "helpers.h"
+#include <wx/resource.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+
+//---------------------------------------------------------------------------
+
+
+
+class wxSize {
+public:
+    %name(width) long x;
+    %name(height)long y;
+
+    wxSize(long w=0, long h=0);
+    ~wxSize();
+    void Set(long w, long h);
+    %name(GetWidth) long GetX();
+    %name(GetHeight)long GetY();
+
+    %addmethods {
+        PyObject* __str__() {
+            PyObject* tup = PyTuple_New(2);
+            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
+            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
+            return tup;
+        }
+    }
+};
+
+//---------------------------------------------------------------------------
+
+class wxRealPoint {
+public:
+    double x;
+    double y;
+    wxRealPoint(double x=0.0, double y=0.0);
+    ~wxRealPoint();
+};
+
+class wxPoint {
+public:
+    long x;
+    long y;
+    wxPoint(long x=0, long y=0);
+    ~wxPoint();
+
+    %addmethods {
+        void Set(long x, long y) {
+            self->x = x;
+            self->y = y;
+        }
+        PyObject* __str__() {
+            PyObject* tup = PyTuple_New(2);
+            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
+            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
+            return tup;
+        }
+    }
+};
+
+//---------------------------------------------------------------------------
+
+class wxRect {
+public:
+   wxRect(long x=0, long y=0, long w=0, long h=0);
+   // TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
+   ~wxRect();
+
+   long  GetX();
+   void SetX(long X);
+   long  GetY();
+   void SetY(long Y);
+   long  GetWidth();
+   void SetWidth(long w);
+   long  GetHeight();
+   void SetHeight(long h);
+
+
+   wxPoint GetPosition();
+   wxSize GetSize();
+
+   long  GetLeft();
+   long  GetTop();
+   long  GetBottom();
+   long  GetRight();
+
+   long x, y, width, height;
+};
+
+
+
+//---------------------------------------------------------------------------
+// Dialog Functions
+
+wxString wxFileSelector(char* message,
+                        char* default_path = NULL,
+                        char* default_filename = NULL,
+                        char* default_extension = NULL,
+                        char* wildcard = "*.*",
+                        int flags = 0,
+                        wxWindow *parent = NULL,
+                        int x = -1, int y = -1);
+
+wxString wxGetTextFromUser(const wxString& message,
+                           const wxString& caption = wxPyEmptyStr,
+                           const wxString& default_value = wxPyEmptyStr,
+                           wxWindow *parent = NULL,
+                           int x = -1, int y = -1,
+                           bool centre = TRUE);
+
+// TODO: Need to custom wrap this one...
+// int wxGetMultipleChoice(char* message, char* caption,
+//                         int LCOUNT, char** LIST,
+//                         int nsel, int *selection,
+//                         wxWindow *parent = NULL, int x = -1, int y = -1,
+//                         bool centre = TRUE, int width=150, int height=200);
+
+
+wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
+                           int LCOUNT, wxString* LIST,
+                           wxWindow *parent = NULL,
+                           int x = -1, int y = -1,
+                           bool centre = TRUE,
+                           int width=150, int height=200);
+
+int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
+                           int LCOUNT, wxString* LIST,
+                           wxWindow *parent = NULL,
+                           int x = -1, int y = -1,
+                           bool centre = TRUE,
+                           int width=150, int height=200);
+
+
+int wxMessageBox(const wxString& message,
+                 const wxString& caption = wxPyEmptyStr,
+                 int style = wxOK | wxCENTRE,
+                 wxWindow *parent = NULL,
+                 int x = -1, int y = -1);
+
+//---------------------------------------------------------------------------
+// GDI Functions
+
+bool wxColourDisplay();
+int wxDisplayDepth();
+void wxSetCursor(wxCursor& cursor);
+
+//---------------------------------------------------------------------------
+// Miscellaneous functions
+
+long NewId();
+void RegisterId(long id);
+void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
+void wxBell();
+void wxDisplaySize(int *OUTPUT, int *OUTPUT);
+void wxEndBusyCursor();
+long wxExecute(const wxString& command, bool sync = FALSE);
+wxWindow * wxFindWindowByLabel(const wxString& label, wxWindow *parent=NULL);
+wxWindow * wxFindWindowByName(const wxString& name, wxWindow *parent=NULL);
+#ifdef __WXMSW__
+wxWindow * wxGetActiveWindow();
+long wxGetElapsedTime(bool resetTimer = TRUE);
+long wxGetFreeMemory();
+#endif
+void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
+bool wxIsBusy();
+wxString wxNow();
+#ifdef __WXMSW__
+bool wxShell(const wxString& command = wxPyEmptyStr);
+void wxStartTimer();
+int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
+#endif
+
+bool wxYield();
+
+%inline %{
+    char* wxGetResource(char *section, char *entry, char *file = NULL) {
+        char * retval;
+        wxGetResource(section, entry, &retval, file);
+        return retval;
+    }
+%}
+
+//---------------------------------------------------------------------------
+// Resource System
+
+bool wxResourceAddIdentifier(char *name, int value);
+void wxResourceClear(void);
+wxBitmap  wxResourceCreateBitmap(char *resource);
+wxIcon  wxResourceCreateIcon(char *resource);
+wxMenuBar * wxResourceCreateMenuBar(char *resource);
+int wxResourceGetIdentifier(char *name);
+bool wxResourceParseData(char *resource, wxResourceTable *table = NULL);
+bool wxResourceParseFile(char *filename, wxResourceTable *table = NULL);
+bool wxResourceParseString(char *resource, wxResourceTable *table = NULL);
+
+
+
+//----------------------------------------------------------------------
+
+class wxPyTimer {
+public:
+    wxPyTimer(PyObject* notify);
+    ~wxPyTimer();
+    int Interval();
+    void Start(int milliseconds=-1, int oneShot=FALSE);
+    void Stop();
+};
+
+//---------------------------------------------------------------------------
+
+enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
+              wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
+enum wxRelationship { wxUnconstrained = 0,
+                      wxAsIs,
+                      wxPercentOf,
+                      wxAbove,
+                      wxBelow,
+                      wxLeftOf,
+                      wxRightOf,
+                      wxSameAs,
+                      wxAbsolute };
+
+
+class wxIndividualLayoutConstraint {
+public:
+//    wxIndividualLayoutConstraint();
+//    ~wxIndividualLayoutConstraint();
+
+    void Above(wxWindow *otherWin, int margin=0);
+    void Absolute(int value);
+    void AsIs();
+    void Below(wxWindow *otherWin, int margin=0);
+    void Unconstrained();
+    void LeftOf(wxWindow *otherWin, int margin=0);
+    void PercentOf(wxWindow *otherWin, wxEdge edge, int percent);
+    void RightOf(wxWindow *otherWin, int margin=0);
+    void SameAs(wxWindow *otherWin, wxEdge edge, int margin=0);
+    void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value=0, int margin=0);
+};
+
+
+class wxLayoutConstraints {
+public:
+    wxLayoutConstraints();
+
+%readonly
+    wxIndividualLayoutConstraint bottom;
+    wxIndividualLayoutConstraint centreX;
+    wxIndividualLayoutConstraint centreY;
+    wxIndividualLayoutConstraint height;
+    wxIndividualLayoutConstraint left;
+    wxIndividualLayoutConstraint right;
+    wxIndividualLayoutConstraint top;
+    wxIndividualLayoutConstraint width;
+%readwrite
+}
+
+
+//---------------------------------------------------------------------------
+// Regions, etc.
+
+enum wxRegionContain {
+	wxOutRegion, wxPartRegion, wxInRegion
+};
+
+
+class wxRegion {
+public:
+    wxRegion();
+    ~wxRegion();
+
+    void Clear();
+    wxRegionContain Contains(long x, long y);
+    %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
+    %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
+
+    wxRect GetBox();
+    bool Intersect(const wxRect& rect);
+#ifdef __WXMSW__
+    bool IsEmpty();
+#endif
+    bool Subtract(const wxRect& rect);
+    bool Union(const wxRect& rect);
+    bool Xor(const wxRect& rect);
+};
+
+
+
+class wxRegionIterator {
+public:
+    wxRegionIterator(const wxRegion& region);
+    ~wxRegionIterator();
+
+    long GetX();
+    long GetY();
+    long GetW();
+    long GetWidth();
+    long GetH();
+    long GetHeight();
+    wxRect GetRect();
+    bool HaveRects();
+    void Reset();
+
+    %addmethods {
+        void Next() {
+            (*self) ++;
+        }
+    };
+};
+
+
+
+//---------------------------------------------------------------------------
+// Accelerator Entry and Table
+
+class wxAcceleratorEntry {
+public:
+    wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
+    //~wxAcceleratorEntry();  *** ?
+
+    void Set(int flags, int keyCode, int Cmd);
+    int GetFlags();
+    int GetKeyCode();
+    int GetCommand();
+};
+
+
+class wxAcceleratorTable {
+public:
+    // Can also accept a list of 3-tuples
+    wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* LIST);
+    // ~wxAcceleratorEntry(); *** ?
+
+};
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.10  1999/01/30 07:30:14  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.9  1998/12/16 22:10:55  RD
+//
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.8  1998/12/15 20:41:22  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.7  1998/11/25 08:45:27  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.6  1998/11/15 23:03:46  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.5  1998/10/20 06:43:59  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.4  1998/08/18 19:48:19  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.3  1998/08/16 04:31:10  RD
+// More wxGTK work.
+//
+// Revision 1.2  1998/08/15 07:36:41  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:51  RD
+// Initial version
+//
+//
+
+

utils/wxPython/src/msw/cmndlgs.py

@@ -0,0 +1,592 @@
+# This file was created automatically by SWIG.
+import cmndlgsc
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+import wx
+class wxColourDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxColourData(self.this)
+    def GetChooseFull(self):
+        val = cmndlgsc.wxColourData_GetChooseFull(self.this)
+        return val
+    def GetColour(self):
+        val = cmndlgsc.wxColourData_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetCustomColour(self,arg0):
+        val = cmndlgsc.wxColourData_GetCustomColour(self.this,arg0)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def SetChooseFull(self,arg0):
+        val = cmndlgsc.wxColourData_SetChooseFull(self.this,arg0)
+        return val
+    def SetColour(self,arg0):
+        val = cmndlgsc.wxColourData_SetColour(self.this,arg0.this)
+        return val
+    def SetCustomColour(self,arg0,arg1):
+        val = cmndlgsc.wxColourData_SetCustomColour(self.this,arg0,arg1.this)
+        return val
+    def __repr__(self):
+        return "<C wxColourData instance>"
+class wxColourData(wxColourDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxColourData()
+        self.thisown = 1
+
+
+
+
+class wxColourDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetColourData(self):
+        val = cmndlgsc.wxColourDialog_GetColourData(self.this)
+        val = wxColourDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxColourDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxColourDialog instance>"
+class wxColourDialog(wxColourDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxColourDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxDirDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPath(self):
+        val = cmndlgsc.wxDirDialog_GetPath(self.this)
+        return val
+    def GetMessage(self):
+        val = cmndlgsc.wxDirDialog_GetMessage(self.this)
+        return val
+    def GetStyle(self):
+        val = cmndlgsc.wxDirDialog_GetStyle(self.this)
+        return val
+    def SetMessage(self,arg0):
+        val = cmndlgsc.wxDirDialog_SetMessage(self.this,arg0)
+        return val
+    def SetPath(self,arg0):
+        val = cmndlgsc.wxDirDialog_SetPath(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxDirDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDirDialog instance>"
+class wxDirDialog(wxDirDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[3] = argl[3].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxDirDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxFileDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetDirectory(self):
+        val = cmndlgsc.wxFileDialog_GetDirectory(self.this)
+        return val
+    def GetFilename(self):
+        val = cmndlgsc.wxFileDialog_GetFilename(self.this)
+        return val
+    def GetFilterIndex(self):
+        val = cmndlgsc.wxFileDialog_GetFilterIndex(self.this)
+        return val
+    def GetMessage(self):
+        val = cmndlgsc.wxFileDialog_GetMessage(self.this)
+        return val
+    def GetPath(self):
+        val = cmndlgsc.wxFileDialog_GetPath(self.this)
+        return val
+    def GetStyle(self):
+        val = cmndlgsc.wxFileDialog_GetStyle(self.this)
+        return val
+    def GetWildcard(self):
+        val = cmndlgsc.wxFileDialog_GetWildcard(self.this)
+        return val
+    def SetDirectory(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetDirectory(self.this,arg0)
+        return val
+    def SetFilename(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetFilename(self.this,arg0)
+        return val
+    def SetFilterIndex(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetFilterIndex(self.this,arg0)
+        return val
+    def SetMessage(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetMessage(self.this,arg0)
+        return val
+    def SetPath(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetPath(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetStyle(self.this,arg0)
+        return val
+    def SetWildcard(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetWildcard(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxFileDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxFileDialog instance>"
+class wxFileDialog(wxFileDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[5] = argl[5].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxFileDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxSingleChoiceDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSelection(self):
+        val = cmndlgsc.wxSingleChoiceDialog_GetSelection(self.this)
+        return val
+    def GetStringSelection(self):
+        val = cmndlgsc.wxSingleChoiceDialog_GetStringSelection(self.this)
+        return val
+    def SetSelection(self,arg0):
+        val = cmndlgsc.wxSingleChoiceDialog_SetSelection(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxSingleChoiceDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxSingleChoiceDialog instance>"
+class wxSingleChoiceDialog(wxSingleChoiceDialogPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,(arg0.this,arg1,arg2,arg3,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxTextEntryDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = cmndlgsc.wxTextEntryDialog_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = cmndlgsc.wxTextEntryDialog_SetValue(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxTextEntryDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTextEntryDialog instance>"
+class wxTextEntryDialog(wxTextEntryDialogPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[3] = argl[3].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxTextEntryDialog,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxFontDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxFontData(self.this)
+    def EnableEffects(self,arg0):
+        val = cmndlgsc.wxFontData_EnableEffects(self.this,arg0)
+        return val
+    def GetAllowSymbols(self):
+        val = cmndlgsc.wxFontData_GetAllowSymbols(self.this)
+        return val
+    def GetColour(self):
+        val = cmndlgsc.wxFontData_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetChosenFont(self):
+        val = cmndlgsc.wxFontData_GetChosenFont(self.this)
+        val = wxFontPtr(val)
+        val.thisown = 1
+        return val
+    def GetEnableEffects(self):
+        val = cmndlgsc.wxFontData_GetEnableEffects(self.this)
+        return val
+    def GetInitialFont(self):
+        val = cmndlgsc.wxFontData_GetInitialFont(self.this)
+        val = wxFontPtr(val)
+        val.thisown = 1
+        return val
+    def GetShowHelp(self):
+        val = cmndlgsc.wxFontData_GetShowHelp(self.this)
+        return val
+    def SetAllowSymbols(self,arg0):
+        val = cmndlgsc.wxFontData_SetAllowSymbols(self.this,arg0)
+        return val
+    def SetChosenFont(self,arg0):
+        val = cmndlgsc.wxFontData_SetChosenFont(self.this,arg0.this)
+        return val
+    def SetColour(self,arg0):
+        val = cmndlgsc.wxFontData_SetColour(self.this,arg0.this)
+        return val
+    def SetInitialFont(self,arg0):
+        val = cmndlgsc.wxFontData_SetInitialFont(self.this,arg0.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = cmndlgsc.wxFontData_SetRange(self.this,arg0,arg1)
+        return val
+    def SetShowHelp(self,arg0):
+        val = cmndlgsc.wxFontData_SetShowHelp(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxFontData instance>"
+class wxFontData(wxFontDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxFontData()
+        self.thisown = 1
+
+
+
+
+class wxFontDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFontData(self):
+        val = cmndlgsc.wxFontDialog_GetFontData(self.this)
+        val = wxFontDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxFontDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxFontDialog instance>"
+class wxFontDialog(wxFontDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxFontDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxPageSetupDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxPageSetupData(self.this)
+    def EnableHelp(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableHelp(self.this,arg0)
+        return val
+    def EnableMargins(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableMargins(self.this,arg0)
+        return val
+    def EnableOrientation(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableOrientation(self.this,arg0)
+        return val
+    def EnablePaper(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnablePaper(self.this,arg0)
+        return val
+    def EnablePrinter(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnablePrinter(self.this,arg0)
+        return val
+    def GetPaperSize(self):
+        val = cmndlgsc.wxPageSetupData_GetPaperSize(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMarginTopLeft(self):
+        val = cmndlgsc.wxPageSetupData_GetMarginTopLeft(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMarginBottomRight(self):
+        val = cmndlgsc.wxPageSetupData_GetMarginBottomRight(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMinMarginTopLeft(self):
+        val = cmndlgsc.wxPageSetupData_GetMinMarginTopLeft(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMinMarginBottomRight(self):
+        val = cmndlgsc.wxPageSetupData_GetMinMarginBottomRight(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetOrientation(self):
+        val = cmndlgsc.wxPageSetupData_GetOrientation(self.this)
+        return val
+    def GetDefaultMinMargins(self):
+        val = cmndlgsc.wxPageSetupData_GetDefaultMinMargins(self.this)
+        return val
+    def GetEnableMargins(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableMargins(self.this)
+        return val
+    def GetEnableOrientation(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableOrientation(self.this)
+        return val
+    def GetEnablePaper(self):
+        val = cmndlgsc.wxPageSetupData_GetEnablePaper(self.this)
+        return val
+    def GetEnablePrinter(self):
+        val = cmndlgsc.wxPageSetupData_GetEnablePrinter(self.this)
+        return val
+    def GetEnableHelp(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableHelp(self.this)
+        return val
+    def GetDefaultInfo(self):
+        val = cmndlgsc.wxPageSetupData_GetDefaultInfo(self.this)
+        return val
+    def SetPaperSize(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetPaperSize(self.this,arg0.this)
+        return val
+    def SetMarginTopLeft(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMarginTopLeft(self.this,arg0.this)
+        return val
+    def SetMarginBottomRight(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMarginBottomRight(self.this,arg0.this)
+        return val
+    def SetMinMarginTopLeft(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMinMarginTopLeft(self.this,arg0.this)
+        return val
+    def SetMinMarginBottomRight(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMinMarginBottomRight(self.this,arg0.this)
+        return val
+    def SetOrientation(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetOrientation(self.this,arg0)
+        return val
+    def SetDefaultMinMargins(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetDefaultMinMargins(self.this,arg0)
+        return val
+    def SetDefaultInfo(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetDefaultInfo(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPageSetupData instance>"
+class wxPageSetupData(wxPageSetupDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxPageSetupData()
+        self.thisown = 1
+
+
+
+
+class wxPageSetupDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPageSetupData(self):
+        val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this)
+        val = wxPageSetupDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPageSetupDialog instance>"
+class wxPageSetupDialog(wxPageSetupDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxPageSetupDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxPrintDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxPrintData(self.this)
+    def EnableHelp(self,arg0):
+        val = cmndlgsc.wxPrintData_EnableHelp(self.this,arg0)
+        return val
+    def EnablePageNumbers(self,arg0):
+        val = cmndlgsc.wxPrintData_EnablePageNumbers(self.this,arg0)
+        return val
+    def EnablePrintToFile(self,arg0):
+        val = cmndlgsc.wxPrintData_EnablePrintToFile(self.this,arg0)
+        return val
+    def EnableSelection(self,arg0):
+        val = cmndlgsc.wxPrintData_EnableSelection(self.this,arg0)
+        return val
+    def GetAllPages(self):
+        val = cmndlgsc.wxPrintData_GetAllPages(self.this)
+        return val
+    def GetCollate(self):
+        val = cmndlgsc.wxPrintData_GetCollate(self.this)
+        return val
+    def GetFromPage(self):
+        val = cmndlgsc.wxPrintData_GetFromPage(self.this)
+        return val
+    def GetMaxPage(self):
+        val = cmndlgsc.wxPrintData_GetMaxPage(self.this)
+        return val
+    def GetMinPage(self):
+        val = cmndlgsc.wxPrintData_GetMinPage(self.this)
+        return val
+    def GetNoCopies(self):
+        val = cmndlgsc.wxPrintData_GetNoCopies(self.this)
+        return val
+    def GetOrientation(self):
+        val = cmndlgsc.wxPrintData_GetOrientation(self.this)
+        return val
+    def GetToPage(self):
+        val = cmndlgsc.wxPrintData_GetToPage(self.this)
+        return val
+    def SetCollate(self,arg0):
+        val = cmndlgsc.wxPrintData_SetCollate(self.this,arg0)
+        return val
+    def SetFromPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetFromPage(self.this,arg0)
+        return val
+    def SetMaxPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetMaxPage(self.this,arg0)
+        return val
+    def SetMinPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetMinPage(self.this,arg0)
+        return val
+    def SetOrientation(self,arg0):
+        val = cmndlgsc.wxPrintData_SetOrientation(self.this,arg0)
+        return val
+    def SetNoCopies(self,arg0):
+        val = cmndlgsc.wxPrintData_SetNoCopies(self.this,arg0)
+        return val
+    def SetPrintToFile(self,arg0):
+        val = cmndlgsc.wxPrintData_SetPrintToFile(self.this,arg0)
+        return val
+    def SetSetupDialog(self,arg0):
+        val = cmndlgsc.wxPrintData_SetSetupDialog(self.this,arg0)
+        return val
+    def SetToPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetToPage(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPrintData instance>"
+class wxPrintData(wxPrintDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxPrintData()
+        self.thisown = 1
+
+
+
+
+class wxPrintDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPrintData(self):
+        val = cmndlgsc.wxPrintDialog_GetPrintData(self.this)
+        val = wxPrintDataPtr(val)
+        return val
+    def GetPrintDC(self):
+        val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this)
+        val = wxDCPtr(val)
+        val.thisown = 1
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxPrintDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPrintDialog instance>"
+class wxPrintDialog(wxPrintDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxPrintDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxMessageDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ShowModal(self):
+        val = cmndlgsc.wxMessageDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMessageDialog instance>"
+class wxMessageDialog(wxMessageDialogPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxMessageDialog,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/controls.py

@@ -0,0 +1,839 @@
+# This file was created automatically by SWIG.
+import controlsc
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from events import *
+import wx
+class wxControlPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Command(self,arg0):
+        val = controlsc.wxControl_Command(self.this,arg0.this)
+        return val
+    def GetLabel(self):
+        val = controlsc.wxControl_GetLabel(self.this)
+        return val
+    def SetLabel(self,arg0):
+        val = controlsc.wxControl_SetLabel(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxControl instance>"
+class wxControl(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetDefault(self):
+        val = controlsc.wxButton_SetDefault(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxButton instance>"
+class wxButton(wxButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxButton,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxBitmapButtonPtr(wxButtonPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBitmapLabel(self):
+        val = controlsc.wxBitmapButton_GetBitmapLabel(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapDisabled(self):
+        val = controlsc.wxBitmapButton_GetBitmapDisabled(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapFocus(self):
+        val = controlsc.wxBitmapButton_GetBitmapFocus(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapSelected(self):
+        val = controlsc.wxBitmapButton_GetBitmapSelected(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetBitmapDisabled(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapDisabled(self.this,arg0.this)
+        return val
+    def SetBitmapFocus(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapFocus(self.this,arg0.this)
+        return val
+    def SetBitmapSelected(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapSelected(self.this,arg0.this)
+        return val
+    def SetBitmapLabel(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapLabel(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxBitmapButton instance>"
+class wxBitmapButton(wxBitmapButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxBitmapButton,(arg0.this,arg1,arg2.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxCheckBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = controlsc.wxCheckBox_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxCheckBox_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxCheckBox instance>"
+class wxCheckBox(wxCheckBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxCheckBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxChoicePtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxChoice_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxChoice_Clear(self.this)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxChoice_FindString(self.this,arg0)
+        return val
+    def GetColumns(self):
+        val = controlsc.wxChoice_GetColumns(self.this)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxChoice_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxChoice_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxChoice_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxChoice_Number(self.this)
+        return val
+    def SetColumns(self,*args):
+        val = apply(controlsc.wxChoice_SetColumns,(self.this,)+args)
+        return val
+    def SetSelection(self,arg0):
+        val = controlsc.wxChoice_SetSelection(self.this,arg0)
+        return val
+    def SetStringSelection(self,arg0):
+        val = controlsc.wxChoice_SetStringSelection(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxChoice instance>"
+class wxChoice(wxChoicePtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxChoice,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxComboBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxComboBox_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxComboBox_Clear(self.this)
+        return val
+    def Copy(self):
+        val = controlsc.wxComboBox_Copy(self.this)
+        return val
+    def Cut(self):
+        val = controlsc.wxComboBox_Cut(self.this)
+        return val
+    def Delete(self,arg0):
+        val = controlsc.wxComboBox_Delete(self.this,arg0)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxComboBox_FindString(self.this,arg0)
+        return val
+    def GetInsertionPoint(self):
+        val = controlsc.wxComboBox_GetInsertionPoint(self.this)
+        return val
+    def GetLastPosition(self):
+        val = controlsc.wxComboBox_GetLastPosition(self.this)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxComboBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxComboBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxComboBox_GetStringSelection(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxComboBox_GetValue(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxComboBox_Number(self.this)
+        return val
+    def Paste(self):
+        val = controlsc.wxComboBox_Paste(self.this)
+        return val
+    def Replace(self,arg0,arg1,arg2):
+        val = controlsc.wxComboBox_Replace(self.this,arg0,arg1,arg2)
+        return val
+    def Remove(self,arg0,arg1):
+        val = controlsc.wxComboBox_Remove(self.this,arg0,arg1)
+        return val
+    def SetInsertionPoint(self,arg0):
+        val = controlsc.wxComboBox_SetInsertionPoint(self.this,arg0)
+        return val
+    def SetInsertionPointEnd(self):
+        val = controlsc.wxComboBox_SetInsertionPointEnd(self.this)
+        return val
+    def SetSelection(self,arg0,*args):
+        val = apply(controlsc.wxComboBox_SetSelection,(self.this,arg0,)+args)
+        return val
+    def SetMark(self,arg0,arg1):
+        val = controlsc.wxComboBox_SetMark(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxComboBox_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxComboBox instance>"
+class wxComboBox(wxComboBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxComboBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxGaugePtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBezelFace(self):
+        val = controlsc.wxGauge_GetBezelFace(self.this)
+        return val
+    def GetRange(self):
+        val = controlsc.wxGauge_GetRange(self.this)
+        return val
+    def GetShadowWidth(self):
+        val = controlsc.wxGauge_GetShadowWidth(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxGauge_GetValue(self.this)
+        return val
+    def SetBezelFace(self,arg0):
+        val = controlsc.wxGauge_SetBezelFace(self.this,arg0)
+        return val
+    def SetRange(self,arg0):
+        val = controlsc.wxGauge_SetRange(self.this,arg0)
+        return val
+    def SetShadowWidth(self,arg0):
+        val = controlsc.wxGauge_SetShadowWidth(self.this,arg0)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxGauge_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxGauge instance>"
+class wxGauge(wxGaugePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxGauge,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxStaticBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxStaticBox instance>"
+class wxStaticBox(wxStaticBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+
+
+
+
+class wxStaticTextPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetLabel(self):
+        val = controlsc.wxStaticText_GetLabel(self.this)
+        return val
+    def SetLabel(self,arg0):
+        val = controlsc.wxStaticText_SetLabel(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxStaticText instance>"
+class wxStaticText(wxStaticTextPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticText,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxListBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxListBox_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxListBox_Clear(self.this)
+        return val
+    def Delete(self,arg0):
+        val = controlsc.wxListBox_Delete(self.this,arg0)
+        return val
+    def Deselect(self,arg0):
+        val = controlsc.wxListBox_Deselect(self.this,arg0)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxListBox_FindString(self.this,arg0)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxListBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxListBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxListBox_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxListBox_Number(self.this)
+        return val
+    def Selected(self,arg0):
+        val = controlsc.wxListBox_Selected(self.this,arg0)
+        return val
+    def Set(self,arg0,*args):
+        val = apply(controlsc.wxListBox_Set,(self.this,arg0,)+args)
+        return val
+    def SetFirstItem(self,arg0):
+        val = controlsc.wxListBox_SetFirstItem(self.this,arg0)
+        return val
+    def SetFirstItemStr(self,arg0):
+        val = controlsc.wxListBox_SetFirstItemStr(self.this,arg0)
+        return val
+    def SetSelection(self,arg0,*args):
+        val = apply(controlsc.wxListBox_SetSelection,(self.this,arg0,)+args)
+        return val
+    def SetString(self,arg0,arg1):
+        val = controlsc.wxListBox_SetString(self.this,arg0,arg1)
+        return val
+    def SetStringSelection(self,arg0,*args):
+        val = apply(controlsc.wxListBox_SetStringSelection,(self.this,arg0,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxListBox instance>"
+class wxListBox(wxListBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxListBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxCheckListBoxPtr(wxListBoxPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsChecked(self,arg0):
+        val = controlsc.wxCheckListBox_IsChecked(self.this,arg0)
+        return val
+    def Check(self,arg0,*args):
+        val = apply(controlsc.wxCheckListBox_Check,(self.this,arg0,)+args)
+        return val
+    def GetItemHeight(self):
+        val = controlsc.wxCheckListBox_GetItemHeight(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCheckListBox instance>"
+class wxCheckListBox(wxCheckListBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxCheckListBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxTextCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Clear(self):
+        val = controlsc.wxTextCtrl_Clear(self.this)
+        return val
+    def Copy(self):
+        val = controlsc.wxTextCtrl_Copy(self.this)
+        return val
+    def Cut(self):
+        val = controlsc.wxTextCtrl_Cut(self.this)
+        return val
+    def DiscardEdits(self):
+        val = controlsc.wxTextCtrl_DiscardEdits(self.this)
+        return val
+    def GetInsertionPoint(self):
+        val = controlsc.wxTextCtrl_GetInsertionPoint(self.this)
+        return val
+    def GetLastPosition(self):
+        val = controlsc.wxTextCtrl_GetLastPosition(self.this)
+        return val
+    def GetLineLength(self,arg0):
+        val = controlsc.wxTextCtrl_GetLineLength(self.this,arg0)
+        return val
+    def GetLineText(self,arg0):
+        val = controlsc.wxTextCtrl_GetLineText(self.this,arg0)
+        return val
+    def GetNumberOfLines(self):
+        val = controlsc.wxTextCtrl_GetNumberOfLines(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxTextCtrl_GetValue(self.this)
+        return val
+    def IsModified(self):
+        val = controlsc.wxTextCtrl_IsModified(self.this)
+        return val
+    def LoadFile(self,arg0):
+        val = controlsc.wxTextCtrl_LoadFile(self.this,arg0)
+        return val
+    def Paste(self):
+        val = controlsc.wxTextCtrl_Paste(self.this)
+        return val
+    def PositionToXY(self,arg0):
+        val = controlsc.wxTextCtrl_PositionToXY(self.this,arg0)
+        return val
+    def Remove(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_Remove(self.this,arg0,arg1)
+        return val
+    def Replace(self,arg0,arg1,arg2):
+        val = controlsc.wxTextCtrl_Replace(self.this,arg0,arg1,arg2)
+        return val
+    def SaveFile(self,arg0):
+        val = controlsc.wxTextCtrl_SaveFile(self.this,arg0)
+        return val
+    def SetEditable(self,arg0):
+        val = controlsc.wxTextCtrl_SetEditable(self.this,arg0)
+        return val
+    def SetInsertionPoint(self,arg0):
+        val = controlsc.wxTextCtrl_SetInsertionPoint(self.this,arg0)
+        return val
+    def SetInsertionPointEnd(self):
+        val = controlsc.wxTextCtrl_SetInsertionPointEnd(self.this)
+        return val
+    def SetSelection(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_SetSelection(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxTextCtrl_SetValue(self.this,arg0)
+        return val
+    def ShowPosition(self,arg0):
+        val = controlsc.wxTextCtrl_ShowPosition(self.this,arg0)
+        return val
+    def WriteText(self,arg0):
+        val = controlsc.wxTextCtrl_WriteText(self.this,arg0)
+        return val
+    def XYToPosition(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_XYToPosition(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxTextCtrl instance>"
+class wxTextCtrl(wxTextCtrlPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxTextCtrl,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxScrollBarPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetRange(self):
+        val = controlsc.wxScrollBar_GetRange(self.this)
+        return val
+    def GetPageSize(self):
+        val = controlsc.wxScrollBar_GetPageSize(self.this)
+        return val
+    def GetThumbPosition(self):
+        val = controlsc.wxScrollBar_GetThumbPosition(self.this)
+        return val
+    def GetThumbSize(self):
+        val = controlsc.wxScrollBar_GetThumbSize(self.this)
+        return val
+    def SetThumbPosition(self,arg0):
+        val = controlsc.wxScrollBar_SetThumbPosition(self.this,arg0)
+        return val
+    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(controlsc.wxScrollBar_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxScrollBar instance>"
+class wxScrollBar(wxScrollBarPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxScrollBar,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSpinButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetMax(self):
+        val = controlsc.wxSpinButton_GetMax(self.this)
+        return val
+    def GetMin(self):
+        val = controlsc.wxSpinButton_GetMin(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxSpinButton_GetValue(self.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = controlsc.wxSpinButton_SetRange(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxSpinButton_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSpinButton instance>"
+class wxSpinButton(wxSpinButtonPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxSpinButton,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxStaticBitmapPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBitmap(self):
+        val = controlsc.wxStaticBitmap_GetBitmap(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetBitmap(self,arg0):
+        val = controlsc.wxStaticBitmap_SetBitmap(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxStaticBitmap instance>"
+class wxStaticBitmap(wxStaticBitmapPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticBitmap,(arg0.this,arg1,arg2.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxRadioBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def EnableBox(self,arg0):
+        val = controlsc.wxRadioBox_EnableBox(self.this,arg0)
+        return val
+    def Enable(self,arg0,arg1):
+        val = controlsc.wxRadioBox_Enable(self.this,arg0,arg1)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxRadioBox_FindString(self.this,arg0)
+        return val
+    def GetBoxLabel(self):
+        val = controlsc.wxRadioBox_GetBoxLabel(self.this)
+        return val
+    def GetLabel(self,arg0):
+        val = controlsc.wxRadioBox_GetLabel(self.this,arg0)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxRadioBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxRadioBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxRadioBox_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxRadioBox_Number(self.this)
+        return val
+    def SetBoxLabel(self,arg0):
+        val = controlsc.wxRadioBox_SetBoxLabel(self.this,arg0)
+        return val
+    def SetLabel(self,arg0,arg1):
+        val = controlsc.wxRadioBox_SetLabel(self.this,arg0,arg1)
+        return val
+    def SetSelection(self,arg0):
+        val = controlsc.wxRadioBox_SetSelection(self.this,arg0)
+        return val
+    def SetStringSelection(self,arg0):
+        val = controlsc.wxRadioBox_SetStringSelection(self.this,arg0)
+        return val
+    def Show(self,arg0):
+        val = controlsc.wxRadioBox_Show(self.this,arg0)
+        return val
+    def ShowItem(self,arg0,arg1):
+        val = controlsc.wxRadioBox_ShowItem(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxRadioBox instance>"
+class wxRadioBox(wxRadioBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxRadioBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxRadioButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = controlsc.wxRadioButton_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxRadioButton_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxRadioButton instance>"
+class wxRadioButton(wxRadioButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxRadioButton,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSliderPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ClearSel(self):
+        val = controlsc.wxSlider_ClearSel(self.this)
+        return val
+    def ClearTicks(self):
+        val = controlsc.wxSlider_ClearTicks(self.this)
+        return val
+    def GetLineSize(self):
+        val = controlsc.wxSlider_GetLineSize(self.this)
+        return val
+    def GetMax(self):
+        val = controlsc.wxSlider_GetMax(self.this)
+        return val
+    def GetMin(self):
+        val = controlsc.wxSlider_GetMin(self.this)
+        return val
+    def GetPageSize(self):
+        val = controlsc.wxSlider_GetPageSize(self.this)
+        return val
+    def GetSelEnd(self):
+        val = controlsc.wxSlider_GetSelEnd(self.this)
+        return val
+    def GetSelStart(self):
+        val = controlsc.wxSlider_GetSelStart(self.this)
+        return val
+    def GetThumbLength(self):
+        val = controlsc.wxSlider_GetThumbLength(self.this)
+        return val
+    def GetTickFreq(self):
+        val = controlsc.wxSlider_GetTickFreq(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxSlider_GetValue(self.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = controlsc.wxSlider_SetRange(self.this,arg0,arg1)
+        return val
+    def SetTickFreq(self,arg0,arg1):
+        val = controlsc.wxSlider_SetTickFreq(self.this,arg0,arg1)
+        return val
+    def SetLineSize(self,arg0):
+        val = controlsc.wxSlider_SetLineSize(self.this,arg0)
+        return val
+    def SetPageSize(self,arg0):
+        val = controlsc.wxSlider_SetPageSize(self.this,arg0)
+        return val
+    def SetSelection(self,arg0,arg1):
+        val = controlsc.wxSlider_SetSelection(self.this,arg0,arg1)
+        return val
+    def SetThumbLength(self,arg0):
+        val = controlsc.wxSlider_SetThumbLength(self.this,arg0)
+        return val
+    def SetTick(self,arg0):
+        val = controlsc.wxSlider_SetTick(self.this,arg0)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxSlider_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSlider instance>"
+class wxSlider(wxSliderPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,arg4,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxSlider,(arg0.this,arg1,arg2,arg3,arg4,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/controls2.py

@@ -0,0 +1,625 @@
+# This file was created automatically by SWIG.
+import controls2c
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from events import *
+
+from controls import *
+import wx
+class wxListItemPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxListItem(self.this)
+    def __setattr__(self,name,value):
+        if name == "m_mask" :
+            controls2c.wxListItem_m_mask_set(self.this,value)
+            return
+        if name == "m_itemId" :
+            controls2c.wxListItem_m_itemId_set(self.this,value)
+            return
+        if name == "m_col" :
+            controls2c.wxListItem_m_col_set(self.this,value)
+            return
+        if name == "m_state" :
+            controls2c.wxListItem_m_state_set(self.this,value)
+            return
+        if name == "m_stateMask" :
+            controls2c.wxListItem_m_stateMask_set(self.this,value)
+            return
+        if name == "m_text" :
+            controls2c.wxListItem_m_text_set(self.this,value)
+            return
+        if name == "m_image" :
+            controls2c.wxListItem_m_image_set(self.this,value)
+            return
+        if name == "m_data" :
+            controls2c.wxListItem_m_data_set(self.this,value)
+            return
+        if name == "m_format" :
+            controls2c.wxListItem_m_format_set(self.this,value)
+            return
+        if name == "m_width" :
+            controls2c.wxListItem_m_width_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_mask" : 
+            return controls2c.wxListItem_m_mask_get(self.this)
+        if name == "m_itemId" : 
+            return controls2c.wxListItem_m_itemId_get(self.this)
+        if name == "m_col" : 
+            return controls2c.wxListItem_m_col_get(self.this)
+        if name == "m_state" : 
+            return controls2c.wxListItem_m_state_get(self.this)
+        if name == "m_stateMask" : 
+            return controls2c.wxListItem_m_stateMask_get(self.this)
+        if name == "m_text" : 
+            return controls2c.wxListItem_m_text_get(self.this)
+        if name == "m_image" : 
+            return controls2c.wxListItem_m_image_get(self.this)
+        if name == "m_data" : 
+            return controls2c.wxListItem_m_data_get(self.this)
+        if name == "m_format" : 
+            return controls2c.wxListItem_m_format_get(self.this)
+        if name == "m_width" : 
+            return controls2c.wxListItem_m_width_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxListItem instance>"
+class wxListItem(wxListItemPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxListItem()
+        self.thisown = 1
+
+
+
+
+class wxListEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __setattr__(self,name,value):
+        if name == "m_code" :
+            controls2c.wxListEvent_m_code_set(self.this,value)
+            return
+        if name == "m_itemIndex" :
+            controls2c.wxListEvent_m_itemIndex_set(self.this,value)
+            return
+        if name == "m_oldItemIndex" :
+            controls2c.wxListEvent_m_oldItemIndex_set(self.this,value)
+            return
+        if name == "m_col" :
+            controls2c.wxListEvent_m_col_set(self.this,value)
+            return
+        if name == "m_cancelled" :
+            controls2c.wxListEvent_m_cancelled_set(self.this,value)
+            return
+        if name == "m_pointDrag" :
+            controls2c.wxListEvent_m_pointDrag_set(self.this,value.this)
+            return
+        if name == "m_item" :
+            controls2c.wxListEvent_m_item_set(self.this,value.this)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_code" : 
+            return controls2c.wxListEvent_m_code_get(self.this)
+        if name == "m_itemIndex" : 
+            return controls2c.wxListEvent_m_itemIndex_get(self.this)
+        if name == "m_oldItemIndex" : 
+            return controls2c.wxListEvent_m_oldItemIndex_get(self.this)
+        if name == "m_col" : 
+            return controls2c.wxListEvent_m_col_get(self.this)
+        if name == "m_cancelled" : 
+            return controls2c.wxListEvent_m_cancelled_get(self.this)
+        if name == "m_pointDrag" : 
+            return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self.this))
+        if name == "m_item" : 
+            return wxListItemPtr(controls2c.wxListEvent_m_item_get(self.this))
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxListEvent instance>"
+class wxListEvent(wxListEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxListCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Arrange(self,*args):
+        val = apply(controls2c.wxListCtrl_Arrange,(self.this,)+args)
+        return val
+    def DeleteItem(self,arg0):
+        val = controls2c.wxListCtrl_DeleteItem(self.this,arg0)
+        return val
+    def DeleteAllItems(self):
+        val = controls2c.wxListCtrl_DeleteAllItems(self.this)
+        return val
+    def DeleteColumn(self,arg0):
+        val = controls2c.wxListCtrl_DeleteColumn(self.this,arg0)
+        return val
+    def DeleteAllColumns(self):
+        val = controls2c.wxListCtrl_DeleteAllColumns(self.this)
+        return val
+    def ClearAll(self):
+        val = controls2c.wxListCtrl_ClearAll(self.this)
+        return val
+    def EditLabel(self,arg0):
+        val = controls2c.wxListCtrl_EditLabel(self.this,arg0)
+        val = wxTextCtrlPtr(val)
+        return val
+    def EndEditLabel(self,arg0):
+        val = controls2c.wxListCtrl_EndEditLabel(self.this,arg0)
+        return val
+    def GetEditControl(self):
+        val = controls2c.wxListCtrl_GetEditControl(self.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def EnsureVisible(self,arg0):
+        val = controls2c.wxListCtrl_EnsureVisible(self.this,arg0)
+        return val
+    def FindItem(self,arg0,arg1,*args):
+        val = apply(controls2c.wxListCtrl_FindItem,(self.this,arg0,arg1,)+args)
+        return val
+    def FindItemData(self,arg0,arg1):
+        val = controls2c.wxListCtrl_FindItemData(self.this,arg0,arg1)
+        return val
+    def FindItemAtPos(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_FindItemAtPos(self.this,arg0,arg1.this,arg2)
+        return val
+    def GetColumn(self,arg0,arg1):
+        val = controls2c.wxListCtrl_GetColumn(self.this,arg0,arg1.this)
+        return val
+    def GetColumnWidth(self,arg0):
+        val = controls2c.wxListCtrl_GetColumnWidth(self.this,arg0)
+        return val
+    def GetCountPerPage(self):
+        val = controls2c.wxListCtrl_GetCountPerPage(self.this)
+        return val
+    def GetImageList(self,arg0):
+        val = controls2c.wxListCtrl_GetImageList(self.this,arg0)
+        return val
+    def GetItemData(self,arg0):
+        val = controls2c.wxListCtrl_GetItemData(self.this,arg0)
+        return val
+    def GetItem(self):
+        val = controls2c.wxListCtrl_GetItem(self.this)
+        val = wxListItemPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemPosition(self,arg0):
+        val = controls2c.wxListCtrl_GetItemPosition(self.this,arg0)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemRect(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_GetItemRect,(self.this,arg0,)+args)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemState(self,arg0,arg1):
+        val = controls2c.wxListCtrl_GetItemState(self.this,arg0,arg1)
+        return val
+    def GetItemCount(self):
+        val = controls2c.wxListCtrl_GetItemCount(self.this)
+        return val
+    def GetItemSpacing(self,arg0):
+        val = controls2c.wxListCtrl_GetItemSpacing(self.this,arg0)
+        return val
+    def GetItemText(self,arg0):
+        val = controls2c.wxListCtrl_GetItemText(self.this,arg0)
+        return val
+    def GetNextItem(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_GetNextItem,(self.this,arg0,)+args)
+        return val
+    def GetSelectedItemCount(self):
+        val = controls2c.wxListCtrl_GetSelectedItemCount(self.this)
+        return val
+    def GetTextColour(self):
+        val = controls2c.wxListCtrl_GetTextColour(self.this)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def SetTextColour(self,arg0):
+        val = controls2c.wxListCtrl_SetTextColour(self.this,arg0.this)
+        return val
+    def GetTopItem(self):
+        val = controls2c.wxListCtrl_GetTopItem(self.this)
+        return val
+    def HitTest(self,arg0):
+        val = controls2c.wxListCtrl_HitTest(self.this,arg0.this)
+        return val
+    def InsertColumnWithInfo(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertColumnWithInfo(self.this,arg0,arg1.this)
+        return val
+    def InsertColumn(self,arg0,arg1,*args):
+        val = apply(controls2c.wxListCtrl_InsertColumn,(self.this,arg0,arg1,)+args)
+        return val
+    def InsertItem(self,arg0):
+        val = controls2c.wxListCtrl_InsertItem(self.this,arg0.this)
+        return val
+    def InsertStringItem(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertStringItem(self.this,arg0,arg1)
+        return val
+    def InsertImageItem(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertImageItem(self.this,arg0,arg1)
+        return val
+    def InsertImageStringItem(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_InsertImageStringItem(self.this,arg0,arg1,arg2)
+        return val
+    def ScrollList(self,arg0,arg1):
+        val = controls2c.wxListCtrl_ScrollList(self.this,arg0,arg1)
+        return val
+    def SetBackgroundColour(self,arg0):
+        val = controls2c.wxListCtrl_SetBackgroundColour(self.this,arg0.this)
+        return val
+    def SetColumn(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetColumn(self.this,arg0,arg1.this)
+        return val
+    def SetColumnWidth(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetColumnWidth(self.this,arg0,arg1)
+        return val
+    def SetImageList(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetImageList(self.this,arg0,arg1)
+        return val
+    def SetItem(self,arg0):
+        val = controls2c.wxListCtrl_SetItem(self.this,arg0.this)
+        return val
+    def SetItemString(self,arg0,arg1,arg2,*args):
+        val = apply(controls2c.wxListCtrl_SetItemString,(self.this,arg0,arg1,arg2,)+args)
+        return val
+    def SetItemData(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemData(self.this,arg0,arg1)
+        return val
+    def SetItemImage(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_SetItemImage(self.this,arg0,arg1,arg2)
+        return val
+    def SetItemPosition(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemPosition(self.this,arg0,arg1.this)
+        return val
+    def SetItemState(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_SetItemState(self.this,arg0,arg1,arg2)
+        return val
+    def SetItemText(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemText(self.this,arg0,arg1)
+        return val
+    def SetSingleStyle(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_SetSingleStyle,(self.this,arg0,)+args)
+        return val
+    def SetWindowStyleFlag(self,arg0):
+        val = controls2c.wxListCtrl_SetWindowStyleFlag(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxListCtrl instance>"
+class wxListCtrl(wxListCtrlPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controls2c.new_wxListCtrl,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxTreeItemIdPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxTreeItemId(self.this)
+    def IsOk(self):
+        val = controls2c.wxTreeItemId_IsOk(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeItemId instance>"
+class wxTreeItemId(wxTreeItemIdPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxTreeItemId()
+        self.thisown = 1
+
+
+
+
+class wxTreeItemDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxTreeItemData(self.this)
+    def GetId(self):
+        val = controls2c.wxTreeItemData_GetId(self.this)
+        val = wxTreeItemIdPtr(val)
+        return val
+    def SetId(self,arg0):
+        val = controls2c.wxTreeItemData_SetId(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeItemData instance>"
+class wxTreeItemData(wxTreeItemDataPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxTreeItemData()
+        self.thisown = 1
+
+
+
+
+class wxTreeEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetItem(self):
+        val = controls2c.wxTreeEvent_GetItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetOldItem(self):
+        val = controls2c.wxTreeEvent_GetOldItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPoint(self):
+        val = controls2c.wxTreeEvent_GetPoint(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetCode(self):
+        val = controls2c.wxTreeEvent_GetCode(self.this)
+        return val
+    def Veto(self):
+        val = controls2c.wxTreeEvent_Veto(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeEvent instance>"
+class wxTreeEvent(wxTreeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxTreeCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetCount(self):
+        val = controls2c.wxTreeCtrl_GetCount(self.this)
+        return val
+    def GetIndent(self):
+        val = controls2c.wxTreeCtrl_GetIndent(self.this)
+        return val
+    def SetIndent(self,arg0):
+        val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
+        return val
+    def GetImageList(self):
+        val = controls2c.wxTreeCtrl_GetImageList(self.this)
+        return val
+    def GetStateImageList(self):
+        val = controls2c.wxTreeCtrl_GetStateImageList(self.this)
+        return val
+    def SetImageList(self,arg0):
+        val = controls2c.wxTreeCtrl_SetImageList(self.this,arg0)
+        return val
+    def SetStateImageList(self,arg0):
+        val = controls2c.wxTreeCtrl_SetStateImageList(self.this,arg0)
+        return val
+    def GetItemText(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0.this)
+        return val
+    def GetItemImage(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemImage(self.this,arg0.this)
+        return val
+    def GetItemSelectedImage(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this)
+        return val
+    def GetItemData(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this)
+        val = wxTreeItemDataPtr(val)
+        return val
+    def SetItemText(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1)
+        return val
+    def SetItemImage(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0.this,arg1)
+        return val
+    def SetItemSelectedImage(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1)
+        return val
+    def SetItemData(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this)
+        return val
+    def SetItemHasChildren(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args)
+        return val
+    def IsVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this)
+        return val
+    def ItemHasChildren(self,arg0):
+        val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0.this)
+        return val
+    def IsExpanded(self,arg0):
+        val = controls2c.wxTreeCtrl_IsExpanded(self.this,arg0.this)
+        return val
+    def IsSelected(self,arg0):
+        val = controls2c.wxTreeCtrl_IsSelected(self.this,arg0.this)
+        return val
+    def GetRootItem(self):
+        val = controls2c.wxTreeCtrl_GetRootItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetSelection(self):
+        val = controls2c.wxTreeCtrl_GetSelection(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetParent(self,arg0):
+        val = controls2c.wxTreeCtrl_GetParent(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetFirstChild(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
+        return val
+    def GetNextChild(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
+        return val
+    def GetNextSibling(self,arg0):
+        val = controls2c.wxTreeCtrl_GetNextSibling(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPrevSibling(self,arg0):
+        val = controls2c.wxTreeCtrl_GetPrevSibling(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetFirstVisibleItem(self):
+        val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetNextVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_GetNextVisible(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPrevVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_GetPrevVisible(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def AddRoot(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_AddRoot,(self.this,arg0,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def PrependItem(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_PrependItem,(self.this,arg0.this,arg1,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def InsertItem(self,arg0,arg1,arg2,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0.this,arg1.this,arg2,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def AppendItem(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_AppendItem,(self.this,arg0.this,arg1,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def Delete(self,arg0):
+        val = controls2c.wxTreeCtrl_Delete(self.this,arg0.this)
+        return val
+    def DeleteChildren(self,arg0):
+        val = controls2c.wxTreeCtrl_DeleteChildren(self.this,arg0.this)
+        return val
+    def DeleteAllItems(self):
+        val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
+        return val
+    def Expand(self,arg0):
+        val = controls2c.wxTreeCtrl_Expand(self.this,arg0.this)
+        return val
+    def Collapse(self,arg0):
+        val = controls2c.wxTreeCtrl_Collapse(self.this,arg0.this)
+        return val
+    def CollapseAndReset(self,arg0):
+        val = controls2c.wxTreeCtrl_CollapseAndReset(self.this,arg0.this)
+        return val
+    def Toggle(self,arg0):
+        val = controls2c.wxTreeCtrl_Toggle(self.this,arg0.this)
+        return val
+    def Unselect(self):
+        val = controls2c.wxTreeCtrl_Unselect(self.this)
+        return val
+    def SelectItem(self,arg0):
+        val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0.this)
+        return val
+    def EnsureVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0.this)
+        return val
+    def ScrollTo(self,arg0):
+        val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0.this)
+        return val
+    def EditLabel(self,arg0):
+        val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def GetEditControl(self):
+        val = controls2c.wxTreeCtrl_GetEditControl(self.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def EndEditLabel(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_EndEditLabel,(self.this,arg0.this,)+args)
+        return val
+    def SetItemBold(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_SetItemBold,(self.this,arg0.this,)+args)
+        return val
+    def IsBold(self,arg0):
+        val = controls2c.wxTreeCtrl_IsBold(self.this,arg0.this)
+        return val
+    def HitTest(self,arg0):
+        val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxTreeCtrl instance>"
+class wxTreeCtrl(wxTreeCtrlPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controls2c.new_wxTreeCtrl,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/events.py

@@ -0,0 +1,630 @@
+# This file was created automatically by SWIG.
+import eventsc
+
+from misc import *
+class wxEventPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetEventObject(self):
+        val = eventsc.wxEvent_GetEventObject(self.this)
+        return val
+    def GetEventType(self):
+        val = eventsc.wxEvent_GetEventType(self.this)
+        return val
+    def GetId(self):
+        val = eventsc.wxEvent_GetId(self.this)
+        return val
+    def GetSkipped(self):
+        val = eventsc.wxEvent_GetSkipped(self.this)
+        return val
+    def GetTimestamp(self):
+        val = eventsc.wxEvent_GetTimestamp(self.this)
+        return val
+    def SetEventObject(self,arg0):
+        val = eventsc.wxEvent_SetEventObject(self.this,arg0)
+        return val
+    def SetEventType(self,arg0):
+        val = eventsc.wxEvent_SetEventType(self.this,arg0)
+        return val
+    def SetId(self,arg0):
+        val = eventsc.wxEvent_SetId(self.this,arg0)
+        return val
+    def SetTimestamp(self,arg0):
+        val = eventsc.wxEvent_SetTimestamp(self.this,arg0)
+        return val
+    def Skip(self,*args):
+        val = apply(eventsc.wxEvent_Skip,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxEvent instance>"
+class wxEvent(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSize(self):
+        val = eventsc.wxSizeEvent_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxSizeEvent instance>"
+class wxSizeEvent(wxSizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCloseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def CanVeto(self):
+        val = eventsc.wxCloseEvent_CanVeto(self.this)
+        return val
+    def GetLoggingOff(self):
+        val = eventsc.wxCloseEvent_GetLoggingOff(self.this)
+        return val
+    def Veto(self,*args):
+        val = apply(eventsc.wxCloseEvent_Veto,(self.this,)+args)
+        return val
+    def GetVeto(self):
+        val = eventsc.wxCloseEvent_GetVeto(self.this)
+        return val
+    def SetForce(self,arg0):
+        val = eventsc.wxCloseEvent_SetForce(self.this,arg0)
+        return val
+    def SetCanVeto(self,arg0):
+        val = eventsc.wxCloseEvent_SetCanVeto(self.this,arg0)
+        return val
+    def SetLoggingOff(self,arg0):
+        val = eventsc.wxCloseEvent_SetLoggingOff(self.this,arg0)
+        return val
+    def GetForce(self):
+        val = eventsc.wxCloseEvent_GetForce(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCloseEvent instance>"
+class wxCloseEvent(wxCloseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCommandEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Checked(self):
+        val = eventsc.wxCommandEvent_Checked(self.this)
+        return val
+    def GetExtraLong(self):
+        val = eventsc.wxCommandEvent_GetExtraLong(self.this)
+        return val
+    def GetInt(self):
+        val = eventsc.wxCommandEvent_GetInt(self.this)
+        return val
+    def GetSelection(self):
+        val = eventsc.wxCommandEvent_GetSelection(self.this)
+        return val
+    def GetString(self):
+        val = eventsc.wxCommandEvent_GetString(self.this)
+        return val
+    def IsSelection(self):
+        val = eventsc.wxCommandEvent_IsSelection(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCommandEvent instance>"
+class wxCommandEvent(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxScrollEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetOrientation(self):
+        val = eventsc.wxScrollEvent_GetOrientation(self.this)
+        return val
+    def GetPosition(self):
+        val = eventsc.wxScrollEvent_GetPosition(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScrollEvent instance>"
+class wxScrollEvent(wxScrollEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSpinEventPtr(wxScrollEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxSpinEvent instance>"
+class wxSpinEvent(wxSpinEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMouseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsButton(self):
+        val = eventsc.wxMouseEvent_IsButton(self.this)
+        return val
+    def ButtonDown(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonDown,(self.this,)+args)
+        return val
+    def ButtonDClick(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonDClick,(self.this,)+args)
+        return val
+    def ButtonUp(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonUp,(self.this,)+args)
+        return val
+    def Button(self,arg0):
+        val = eventsc.wxMouseEvent_Button(self.this,arg0)
+        return val
+    def ButtonIsDown(self,arg0):
+        val = eventsc.wxMouseEvent_ButtonIsDown(self.this,arg0)
+        return val
+    def ControlDown(self):
+        val = eventsc.wxMouseEvent_ControlDown(self.this)
+        return val
+    def MetaDown(self):
+        val = eventsc.wxMouseEvent_MetaDown(self.this)
+        return val
+    def AltDown(self):
+        val = eventsc.wxMouseEvent_AltDown(self.this)
+        return val
+    def ShiftDown(self):
+        val = eventsc.wxMouseEvent_ShiftDown(self.this)
+        return val
+    def LeftDown(self):
+        val = eventsc.wxMouseEvent_LeftDown(self.this)
+        return val
+    def MiddleDown(self):
+        val = eventsc.wxMouseEvent_MiddleDown(self.this)
+        return val
+    def RightDown(self):
+        val = eventsc.wxMouseEvent_RightDown(self.this)
+        return val
+    def LeftUp(self):
+        val = eventsc.wxMouseEvent_LeftUp(self.this)
+        return val
+    def MiddleUp(self):
+        val = eventsc.wxMouseEvent_MiddleUp(self.this)
+        return val
+    def RightUp(self):
+        val = eventsc.wxMouseEvent_RightUp(self.this)
+        return val
+    def LeftDClick(self):
+        val = eventsc.wxMouseEvent_LeftDClick(self.this)
+        return val
+    def MiddleDClick(self):
+        val = eventsc.wxMouseEvent_MiddleDClick(self.this)
+        return val
+    def RightDClick(self):
+        val = eventsc.wxMouseEvent_RightDClick(self.this)
+        return val
+    def LeftIsDown(self):
+        val = eventsc.wxMouseEvent_LeftIsDown(self.this)
+        return val
+    def MiddleIsDown(self):
+        val = eventsc.wxMouseEvent_MiddleIsDown(self.this)
+        return val
+    def RightIsDown(self):
+        val = eventsc.wxMouseEvent_RightIsDown(self.this)
+        return val
+    def Dragging(self):
+        val = eventsc.wxMouseEvent_Dragging(self.this)
+        return val
+    def Moving(self):
+        val = eventsc.wxMouseEvent_Moving(self.this)
+        return val
+    def Entering(self):
+        val = eventsc.wxMouseEvent_Entering(self.this)
+        return val
+    def Leaving(self):
+        val = eventsc.wxMouseEvent_Leaving(self.this)
+        return val
+    def Position(self):
+        val = eventsc.wxMouseEvent_Position(self.this)
+        return val
+    def GetPosition(self):
+        val = eventsc.wxMouseEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetLogicalPosition(self,arg0):
+        val = eventsc.wxMouseEvent_GetLogicalPosition(self.this,arg0.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetX(self):
+        val = eventsc.wxMouseEvent_GetX(self.this)
+        return val
+    def GetY(self):
+        val = eventsc.wxMouseEvent_GetY(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMouseEvent instance>"
+class wxMouseEvent(wxMouseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxKeyEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ControlDown(self):
+        val = eventsc.wxKeyEvent_ControlDown(self.this)
+        return val
+    def MetaDown(self):
+        val = eventsc.wxKeyEvent_MetaDown(self.this)
+        return val
+    def AltDown(self):
+        val = eventsc.wxKeyEvent_AltDown(self.this)
+        return val
+    def ShiftDown(self):
+        val = eventsc.wxKeyEvent_ShiftDown(self.this)
+        return val
+    def KeyCode(self):
+        val = eventsc.wxKeyEvent_KeyCode(self.this)
+        return val
+    def Position(self):
+        val = eventsc.wxKeyEvent_Position(self.this)
+        return val
+    def GetX(self):
+        val = eventsc.wxKeyEvent_GetX(self.this)
+        return val
+    def GetY(self):
+        val = eventsc.wxKeyEvent_GetY(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxKeyEvent instance>"
+class wxKeyEvent(wxKeyEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMoveEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxMoveEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxMoveEvent instance>"
+class wxMoveEvent(wxMoveEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxPaintEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPaintEvent instance>"
+class wxPaintEvent(wxPaintEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxEraseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetDC(self):
+        val = eventsc.wxEraseEvent_GetDC(self.this)
+        val = wxDCPtr(val)
+        return val
+    def __repr__(self):
+        return "<C wxEraseEvent instance>"
+class wxEraseEvent(wxEraseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxFocusEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxFocusEvent instance>"
+class wxFocusEvent(wxFocusEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxActivateEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetActive(self):
+        val = eventsc.wxActivateEvent_GetActive(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxActivateEvent instance>"
+class wxActivateEvent(wxActivateEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxInitDialogEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxInitDialogEvent instance>"
+class wxInitDialogEvent(wxInitDialogEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMenuEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetMenuId(self):
+        val = eventsc.wxMenuEvent_GetMenuId(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMenuEvent instance>"
+class wxMenuEvent(wxMenuEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxShowEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetShow(self,arg0):
+        val = eventsc.wxShowEvent_SetShow(self.this,arg0)
+        return val
+    def GetShow(self):
+        val = eventsc.wxShowEvent_GetShow(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxShowEvent instance>"
+class wxShowEvent(wxShowEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxIconizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxIconizeEvent instance>"
+class wxIconizeEvent(wxIconizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMaximizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMaximizeEvent instance>"
+class wxMaximizeEvent(wxMaximizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxJoystickEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxJoystickEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetZPosition(self):
+        val = eventsc.wxJoystickEvent_GetZPosition(self.this)
+        return val
+    def GetButtonState(self):
+        val = eventsc.wxJoystickEvent_GetButtonState(self.this)
+        return val
+    def GetButtonChange(self):
+        val = eventsc.wxJoystickEvent_GetButtonChange(self.this)
+        return val
+    def GetJoystick(self):
+        val = eventsc.wxJoystickEvent_GetJoystick(self.this)
+        return val
+    def SetJoystick(self,arg0):
+        val = eventsc.wxJoystickEvent_SetJoystick(self.this,arg0)
+        return val
+    def SetButtonState(self,arg0):
+        val = eventsc.wxJoystickEvent_SetButtonState(self.this,arg0)
+        return val
+    def SetButtonChange(self,arg0):
+        val = eventsc.wxJoystickEvent_SetButtonChange(self.this,arg0)
+        return val
+    def SetPosition(self,arg0):
+        val = eventsc.wxJoystickEvent_SetPosition(self.this,arg0.this)
+        return val
+    def SetZPosition(self,arg0):
+        val = eventsc.wxJoystickEvent_SetZPosition(self.this,arg0)
+        return val
+    def IsButton(self):
+        val = eventsc.wxJoystickEvent_IsButton(self.this)
+        return val
+    def IsMove(self):
+        val = eventsc.wxJoystickEvent_IsMove(self.this)
+        return val
+    def IsZMove(self):
+        val = eventsc.wxJoystickEvent_IsZMove(self.this)
+        return val
+    def ButtonDown(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonDown,(self.this,)+args)
+        return val
+    def ButtonUp(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonUp,(self.this,)+args)
+        return val
+    def ButtonIsDown(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxJoystickEvent instance>"
+class wxJoystickEvent(wxJoystickEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxDropFilesEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxDropFilesEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetNumberOfFiles(self):
+        val = eventsc.wxDropFilesEvent_GetNumberOfFiles(self.this)
+        return val
+    def GetFiles(self):
+        val = eventsc.wxDropFilesEvent_GetFiles(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDropFilesEvent instance>"
+class wxDropFilesEvent(wxDropFilesEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxIdleEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def RequestMore(self,*args):
+        val = apply(eventsc.wxIdleEvent_RequestMore,(self.this,)+args)
+        return val
+    def MoreRequested(self):
+        val = eventsc.wxIdleEvent_MoreRequested(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxIdleEvent instance>"
+class wxIdleEvent(wxIdleEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxUpdateUIEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetChecked(self):
+        val = eventsc.wxUpdateUIEvent_GetChecked(self.this)
+        return val
+    def GetEnabled(self):
+        val = eventsc.wxUpdateUIEvent_GetEnabled(self.this)
+        return val
+    def GetText(self):
+        val = eventsc.wxUpdateUIEvent_GetText(self.this)
+        return val
+    def GetSetText(self):
+        val = eventsc.wxUpdateUIEvent_GetSetText(self.this)
+        return val
+    def GetSetChecked(self):
+        val = eventsc.wxUpdateUIEvent_GetSetChecked(self.this)
+        return val
+    def GetSetEnabled(self):
+        val = eventsc.wxUpdateUIEvent_GetSetEnabled(self.this)
+        return val
+    def Check(self,arg0):
+        val = eventsc.wxUpdateUIEvent_Check(self.this,arg0)
+        return val
+    def Enable(self,arg0):
+        val = eventsc.wxUpdateUIEvent_Enable(self.this,arg0)
+        return val
+    def SetText(self,arg0):
+        val = eventsc.wxUpdateUIEvent_SetText(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxUpdateUIEvent instance>"
+class wxUpdateUIEvent(wxUpdateUIEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSysColourChangedEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxSysColourChangedEvent instance>"
+class wxSysColourChangedEvent(wxSysColourChangedEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/frames.py

@@ -0,0 +1,127 @@
+# This file was created automatically by SWIG.
+import framesc
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+
+from stattool import *
+
+from controls import *
+
+from events import *
+import wx
+class wxFramePtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Centre(self,*args):
+        val = apply(framesc.wxFrame_Centre,(self.this,)+args)
+        return val
+    def Command(self,arg0):
+        val = framesc.wxFrame_Command(self.this,arg0)
+        return val
+    def CreateStatusBar(self,*args):
+        val = apply(framesc.wxFrame_CreateStatusBar,(self.this,)+args)
+        val = wxStatusBarPtr(val)
+        return val
+    def CreateToolBar(self,*args):
+        val = apply(framesc.wxFrame_CreateToolBar,(self.this,)+args)
+        val = wxToolBarPtr(val)
+        return val
+    def GetMenuBar(self):
+        val = framesc.wxFrame_GetMenuBar(self.this)
+        val = wxMenuBarPtr(val)
+        return val
+    def GetStatusBar(self):
+        val = framesc.wxFrame_GetStatusBar(self.this)
+        val = wxStatusBarPtr(val)
+        return val
+    def GetTitle(self):
+        val = framesc.wxFrame_GetTitle(self.this)
+        return val
+    def GetToolBar(self):
+        val = framesc.wxFrame_GetToolBar(self.this)
+        val = wxToolBarPtr(val)
+        return val
+    def Iconize(self,arg0):
+        val = framesc.wxFrame_Iconize(self.this,arg0)
+        return val
+    def IsIconized(self):
+        val = framesc.wxFrame_IsIconized(self.this)
+        return val
+    def Maximize(self,arg0):
+        val = framesc.wxFrame_Maximize(self.this,arg0)
+        return val
+    def SetAcceleratorTable(self,arg0):
+        val = framesc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
+        return val
+    def SetIcon(self,arg0):
+        val = framesc.wxFrame_SetIcon(self.this,arg0.this)
+        return val
+    def SetMenuBar(self,arg0):
+        val = framesc.wxFrame_SetMenuBar(self.this,arg0.this)
+        return val
+    def SetStatusBar(self,arg0):
+        val = framesc.wxFrame_SetStatusBar(self.this,arg0.this)
+        return val
+    def SetStatusText(self,arg0,*args):
+        val = apply(framesc.wxFrame_SetStatusText,(self.this,arg0,)+args)
+        return val
+    def SetStatusWidths(self,arg0,*args):
+        val = apply(framesc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
+        return val
+    def SetTitle(self,arg0):
+        val = framesc.wxFrame_SetTitle(self.this,arg0)
+        return val
+    def SetToolBar(self,arg0):
+        val = framesc.wxFrame_SetToolBar(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxFrame instance>"
+class wxFrame(wxFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(framesc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+class wxMiniFramePtr(wxFramePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMiniFrame instance>"
+class wxMiniFrame(wxMiniFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(framesc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/gdi.py

@@ -0,0 +1,795 @@
+# This file was created automatically by SWIG.
+import gdic
+
+from misc import *
+class wxBitmapPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxBitmap(self.this)
+    def Create(self,arg0,arg1,*args):
+        val = apply(gdic.wxBitmap_Create,(self.this,arg0,arg1,)+args)
+        return val
+    def GetDepth(self):
+        val = gdic.wxBitmap_GetDepth(self.this)
+        return val
+    def GetHeight(self):
+        val = gdic.wxBitmap_GetHeight(self.this)
+        return val
+    def GetPalette(self):
+        val = gdic.wxBitmap_GetPalette(self.this)
+        val = wxPalettePtr(val)
+        return val
+    def GetMask(self):
+        val = gdic.wxBitmap_GetMask(self.this)
+        val = wxMaskPtr(val)
+        return val
+    def GetWidth(self):
+        val = gdic.wxBitmap_GetWidth(self.this)
+        return val
+    def LoadFile(self,arg0,arg1):
+        val = gdic.wxBitmap_LoadFile(self.this,arg0,arg1)
+        return val
+    def Ok(self):
+        val = gdic.wxBitmap_Ok(self.this)
+        return val
+    def SaveFile(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxBitmap_SaveFile,(self.this,arg0,arg1,)+args)
+        return val
+    def SetDepth(self,arg0):
+        val = gdic.wxBitmap_SetDepth(self.this,arg0)
+        return val
+    def SetHeight(self,arg0):
+        val = gdic.wxBitmap_SetHeight(self.this,arg0)
+        return val
+    def SetMask(self,arg0):
+        val = gdic.wxBitmap_SetMask(self.this,arg0.this)
+        return val
+    def SetPalette(self,arg0):
+        val = gdic.wxBitmap_SetPalette(self.this,arg0.this)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxBitmap_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxBitmap instance>"
+class wxBitmap(wxBitmapPtr):
+    def __init__(self,arg0,arg1) :
+        self.this = gdic.new_wxBitmap(arg0,arg1)
+        self.thisown = 1
+
+
+
+
+class wxMaskPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxMask(self.this)
+    def __repr__(self):
+        return "<C wxMask instance>"
+class wxMask(wxMaskPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxMask(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxIconPtr(wxBitmapPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxIcon(self.this)
+    def GetDepth(self):
+        val = gdic.wxIcon_GetDepth(self.this)
+        return val
+    def GetHeight(self):
+        val = gdic.wxIcon_GetHeight(self.this)
+        return val
+    def GetWidth(self):
+        val = gdic.wxIcon_GetWidth(self.this)
+        return val
+    def LoadFile(self,arg0,arg1):
+        val = gdic.wxIcon_LoadFile(self.this,arg0,arg1)
+        return val
+    def Ok(self):
+        val = gdic.wxIcon_Ok(self.this)
+        return val
+    def SetDepth(self,arg0):
+        val = gdic.wxIcon_SetDepth(self.this,arg0)
+        return val
+    def SetHeight(self,arg0):
+        val = gdic.wxIcon_SetHeight(self.this,arg0)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxIcon_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxIcon instance>"
+class wxIcon(wxIconPtr):
+    def __init__(self,arg0,arg1,*args) :
+        self.this = apply(gdic.new_wxIcon,(arg0,arg1,)+args)
+        self.thisown = 1
+
+
+
+
+class wxCursorPtr(wxBitmapPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxCursor(self.this)
+    def Ok(self):
+        val = gdic.wxCursor_Ok(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCursor instance>"
+class wxCursor(wxCursorPtr):
+    def __init__(self,arg0,arg1,*args) :
+        self.this = apply(gdic.new_wxCursor,(arg0,arg1,)+args)
+        self.thisown = 1
+
+
+
+
+class wxFontPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFaceName(self):
+        val = gdic.wxFont_GetFaceName(self.this)
+        return val
+    def GetFamily(self):
+        val = gdic.wxFont_GetFamily(self.this)
+        return val
+    def GetFontId(self):
+        val = gdic.wxFont_GetFontId(self.this)
+        return val
+    def GetPointSize(self):
+        val = gdic.wxFont_GetPointSize(self.this)
+        return val
+    def GetStyle(self):
+        val = gdic.wxFont_GetStyle(self.this)
+        return val
+    def GetUnderlined(self):
+        val = gdic.wxFont_GetUnderlined(self.this)
+        return val
+    def GetWeight(self):
+        val = gdic.wxFont_GetWeight(self.this)
+        return val
+    def SetFaceName(self,arg0):
+        val = gdic.wxFont_SetFaceName(self.this,arg0)
+        return val
+    def SetFamily(self,arg0):
+        val = gdic.wxFont_SetFamily(self.this,arg0)
+        return val
+    def SetPointSize(self,arg0):
+        val = gdic.wxFont_SetPointSize(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxFont_SetStyle(self.this,arg0)
+        return val
+    def SetUnderlined(self,arg0):
+        val = gdic.wxFont_SetUnderlined(self.this,arg0)
+        return val
+    def SetWeight(self,arg0):
+        val = gdic.wxFont_SetWeight(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxFont instance>"
+class wxFont(wxFontPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,*args) :
+        self.this = apply(gdic.new_wxFont,(arg0,arg1,arg2,arg3,)+args)
+        self.thisown = 1
+
+
+
+
+class wxColourPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxColour(self.this)
+    def Red(self):
+        val = gdic.wxColour_Red(self.this)
+        return val
+    def Green(self):
+        val = gdic.wxColour_Green(self.this)
+        return val
+    def Blue(self):
+        val = gdic.wxColour_Blue(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxColour_Ok(self.this)
+        return val
+    def Set(self,arg0,arg1,arg2):
+        val = gdic.wxColour_Set(self.this,arg0,arg1,arg2)
+        return val
+    def Get(self):
+        val = gdic.wxColour_Get(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxColour instance>"
+class wxColour(wxColourPtr):
+    def __init__(self,*args) :
+        self.this = apply(gdic.new_wxColour,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPenPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetCap(self):
+        val = gdic.wxPen_GetCap(self.this)
+        return val
+    def GetColour(self):
+        val = gdic.wxPen_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetJoin(self):
+        val = gdic.wxPen_GetJoin(self.this)
+        return val
+    def GetStyle(self):
+        val = gdic.wxPen_GetStyle(self.this)
+        return val
+    def GetWidth(self):
+        val = gdic.wxPen_GetWidth(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxPen_Ok(self.this)
+        return val
+    def SetCap(self,arg0):
+        val = gdic.wxPen_SetCap(self.this,arg0)
+        return val
+    def SetColour(self,arg0):
+        val = gdic.wxPen_SetColour(self.this,arg0.this)
+        return val
+    def SetJoin(self,arg0):
+        val = gdic.wxPen_SetJoin(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxPen_SetStyle(self.this,arg0)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxPen_SetWidth(self.this,arg0)
+        return val
+    def GetDashes(self,arg0):
+        val = gdic.wxPen_GetDashes(self.this,arg0)
+        return val
+    def GetStipple(self):
+        val = gdic.wxPen_GetStipple(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetDashes(self,arg0,*args):
+        val = apply(gdic.wxPen_SetDashes,(self.this,arg0,)+args)
+        return val
+    def SetStipple(self,arg0):
+        val = gdic.wxPen_SetStipple(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxPen instance>"
+class wxPen(wxPenPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(gdic.new_wxPen,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxBrushPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetColour(self):
+        val = gdic.wxBrush_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetStipple(self):
+        val = gdic.wxBrush_GetStipple(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetStyle(self):
+        val = gdic.wxBrush_GetStyle(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxBrush_Ok(self.this)
+        return val
+    def SetColour(self,arg0):
+        val = gdic.wxBrush_SetColour(self.this,arg0.this)
+        return val
+    def SetStipple(self,arg0):
+        val = gdic.wxBrush_SetStipple(self.this,arg0.this)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxBrush_SetStyle(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxBrush instance>"
+class wxBrush(wxBrushPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(gdic.new_wxBrush,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxDCPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxDC(self.this)
+    def BeginDrawing(self):
+        val = gdic.wxDC_BeginDrawing(self.this)
+        return val
+    def Blit(self,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7):
+        val = gdic.wxDC_Blit(self.this,arg0,arg1,arg2,arg3,arg4.this,arg5,arg6,arg7)
+        return val
+    def Clear(self):
+        val = gdic.wxDC_Clear(self.this)
+        return val
+    def CrossHair(self,arg0,arg1):
+        val = gdic.wxDC_CrossHair(self.this,arg0,arg1)
+        return val
+    def DestroyClippingRegion(self):
+        val = gdic.wxDC_DestroyClippingRegion(self.this)
+        return val
+    def DeviceToLogicalX(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalX(self.this,arg0)
+        return val
+    def DeviceToLogicalXRel(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalXRel(self.this,arg0)
+        return val
+    def DeviceToLogicalY(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalY(self.this,arg0)
+        return val
+    def DeviceToLogicalYRel(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalYRel(self.this,arg0)
+        return val
+    def DrawArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
+        val = gdic.wxDC_DrawArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
+        return val
+    def DrawEllipse(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawEllipse(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawEllipticArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
+        val = gdic.wxDC_DrawEllipticArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
+        return val
+    def DrawIcon(self,arg0,arg1,arg2):
+        val = gdic.wxDC_DrawIcon(self.this,arg0.this,arg1,arg2)
+        return val
+    def DrawLine(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawLine(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawLines(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawLines,(self.this,arg0,)+args)
+        return val
+    def DrawPolygon(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawPolygon,(self.this,arg0,)+args)
+        return val
+    def DrawPoint(self,arg0,arg1):
+        val = gdic.wxDC_DrawPoint(self.this,arg0,arg1)
+        return val
+    def DrawRectangle(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawRectangle(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawRoundedRectangle(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(gdic.wxDC_DrawRoundedRectangle,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def DrawSpline(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawSpline,(self.this,arg0,)+args)
+        return val
+    def DrawText(self,arg0,arg1,arg2):
+        val = gdic.wxDC_DrawText(self.this,arg0,arg1,arg2)
+        return val
+    def EndDoc(self):
+        val = gdic.wxDC_EndDoc(self.this)
+        return val
+    def EndDrawing(self):
+        val = gdic.wxDC_EndDrawing(self.this)
+        return val
+    def EndPage(self):
+        val = gdic.wxDC_EndPage(self.this)
+        return val
+    def FloodFill(self,arg0,arg1,arg2,*args):
+        val = apply(gdic.wxDC_FloodFill,(self.this,arg0,arg1,arg2.this,)+args)
+        return val
+    def GetBackground(self):
+        val = gdic.wxDC_GetBackground(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetBrush(self):
+        val = gdic.wxDC_GetBrush(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetCharHeight(self):
+        val = gdic.wxDC_GetCharHeight(self.this)
+        return val
+    def GetCharWidth(self):
+        val = gdic.wxDC_GetCharWidth(self.this)
+        return val
+    def GetClippingBox(self):
+        val = gdic.wxDC_GetClippingBox(self.this)
+        return val
+    def GetFont(self):
+        val = gdic.wxDC_GetFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetLogicalFunction(self):
+        val = gdic.wxDC_GetLogicalFunction(self.this)
+        return val
+    def GetMapMode(self):
+        val = gdic.wxDC_GetMapMode(self.this)
+        return val
+    def GetOptimization(self):
+        val = gdic.wxDC_GetOptimization(self.this)
+        return val
+    def GetPen(self):
+        val = gdic.wxDC_GetPen(self.this)
+        val = wxPenPtr(val)
+        return val
+    def GetPixel(self,arg0,arg1):
+        val = gdic.wxDC_GetPixel(self.this,arg0,arg1)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def GetSize(self):
+        val = gdic.wxDC_GetSize(self.this)
+        return val
+    def GetTextBackground(self):
+        val = gdic.wxDC_GetTextBackground(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetTextExtent(self,arg0):
+        val = gdic.wxDC_GetTextExtent(self.this,arg0)
+        return val
+    def GetTextForeground(self):
+        val = gdic.wxDC_GetTextForeground(self.this)
+        val = wxColourPtr(val)
+        return val
+    def LogicalToDeviceX(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceX(self.this,arg0)
+        return val
+    def LogicalToDeviceXRel(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceXRel(self.this,arg0)
+        return val
+    def LogicalToDeviceY(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceY(self.this,arg0)
+        return val
+    def LogicalToDeviceYRel(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceYRel(self.this,arg0)
+        return val
+    def MaxX(self):
+        val = gdic.wxDC_MaxX(self.this)
+        return val
+    def MaxY(self):
+        val = gdic.wxDC_MaxY(self.this)
+        return val
+    def MinX(self):
+        val = gdic.wxDC_MinX(self.this)
+        return val
+    def MinY(self):
+        val = gdic.wxDC_MinY(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxDC_Ok(self.this)
+        return val
+    def SetDeviceOrigin(self,arg0,arg1):
+        val = gdic.wxDC_SetDeviceOrigin(self.this,arg0,arg1)
+        return val
+    def SetBackground(self,arg0):
+        val = gdic.wxDC_SetBackground(self.this,arg0.this)
+        return val
+    def SetBackgroundMode(self,arg0):
+        val = gdic.wxDC_SetBackgroundMode(self.this,arg0)
+        return val
+    def SetClippingRegion(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_SetClippingRegion(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def SetPalette(self,arg0):
+        val = gdic.wxDC_SetPalette(self.this,arg0.this)
+        return val
+    def SetBrush(self,arg0):
+        val = gdic.wxDC_SetBrush(self.this,arg0.this)
+        return val
+    def SetFont(self,arg0):
+        val = gdic.wxDC_SetFont(self.this,arg0.this)
+        return val
+    def SetLogicalFunction(self,arg0):
+        val = gdic.wxDC_SetLogicalFunction(self.this,arg0)
+        return val
+    def SetMapMode(self,arg0):
+        val = gdic.wxDC_SetMapMode(self.this,arg0)
+        return val
+    def SetOptimization(self,arg0):
+        val = gdic.wxDC_SetOptimization(self.this,arg0)
+        return val
+    def SetPen(self,arg0):
+        val = gdic.wxDC_SetPen(self.this,arg0.this)
+        return val
+    def SetTextBackground(self,arg0):
+        val = gdic.wxDC_SetTextBackground(self.this,arg0.this)
+        return val
+    def SetTextForeground(self,arg0):
+        val = gdic.wxDC_SetTextForeground(self.this,arg0.this)
+        return val
+    def SetUserScale(self,arg0,arg1):
+        val = gdic.wxDC_SetUserScale(self.this,arg0,arg1)
+        return val
+    def StartDoc(self,arg0):
+        val = gdic.wxDC_StartDoc(self.this,arg0)
+        return val
+    def StartPage(self):
+        val = gdic.wxDC_StartPage(self.this)
+        return val
+    def DrawBitmap(self,arg0,arg1,arg2,*args):
+        val = apply(gdic.wxDC_DrawBitmap,(self.this,arg0.this,arg1,arg2,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxDC instance>"
+class wxDC(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMemoryDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SelectObject(self,arg0):
+        val = gdic.wxMemoryDC_SelectObject(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxMemoryDC instance>"
+class wxMemoryDC(wxMemoryDCPtr):
+    def __init__(self) :
+        self.this = gdic.new_wxMemoryDC()
+        self.thisown = 1
+
+
+
+
+class wxScreenDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def StartDrawingOnTop(self,arg0):
+        val = gdic.wxScreenDC_StartDrawingOnTop(self.this,arg0.this)
+        return val
+    def StartDrawingOnTopRect(self,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxScreenDC_StartDrawingOnTopRect,(self.this,)+args)
+        return val
+    def EndDrawingOnTop(self):
+        val = gdic.wxScreenDC_EndDrawingOnTop(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScreenDC instance>"
+class wxScreenDC(wxScreenDCPtr):
+    def __init__(self) :
+        self.this = gdic.new_wxScreenDC()
+        self.thisown = 1
+
+
+
+
+class wxClientDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxClientDC instance>"
+class wxClientDC(wxClientDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxClientDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxPaintDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPaintDC instance>"
+class wxPaintDC(wxPaintDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxPaintDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxWindowDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxWindowDC instance>"
+class wxWindowDC(wxWindowDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxWindowDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxPrinterDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPrinterDC instance>"
+class wxPrinterDC(wxPrinterDCPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        self.this = apply(gdic.new_wxPrinterDC,(arg0,arg1,arg2,)+args)
+        self.thisown = 1
+
+
+
+
+class wxMetaFileDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Close(self):
+        val = gdic.wxMetaFileDC_Close(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMetaFileDC instance>"
+class wxMetaFileDC(wxMetaFileDCPtr):
+    def __init__(self,*args) :
+        self.this = apply(gdic.new_wxMetaFileDC,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPalettePtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxPalette(self.this)
+    def GetPixel(self,arg0,arg1,arg2):
+        val = gdic.wxPalette_GetPixel(self.this,arg0,arg1,arg2)
+        return val
+    def GetRGB(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxPalette_GetRGB(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def Ok(self):
+        val = gdic.wxPalette_Ok(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPalette instance>"
+class wxPalette(wxPalettePtr):
+    def __init__(self,arg0,arg1,arg2) :
+        self.this = gdic.new_wxPalette(arg0,arg1,arg2)
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+def wxEmptyBitmap(arg0,arg1,*args):
+    val = apply(gdic.wxEmptyBitmap,(arg0,arg1,)+args)
+    val = wxBitmapPtr(val)
+    val.thisown = 1
+    return val
+
+def wxNoRefBitmap(arg0,arg1):
+    val = gdic.wxNoRefBitmap(arg0,arg1)
+    val = wxBitmapPtr(val)
+    return val
+
+def wxMaskColour(arg0,arg1):
+    val = gdic.wxMaskColour(arg0.this,arg1.this)
+    val = wxMaskPtr(val)
+    val.thisown = 1
+    return val
+
+def wxStockCursor(arg0):
+    val = gdic.wxStockCursor(arg0)
+    val = wxCursorPtr(val)
+    val.thisown = 1
+    return val
+
+def wxNamedColour(arg0):
+    val = gdic.wxNamedColour(arg0)
+    val = wxColourPtr(val)
+    val.thisown = 1
+    return val
+
+def wxMemoryDCFromDC(arg0):
+    val = gdic.wxMemoryDCFromDC(arg0.this)
+    val = wxMemoryDCPtr(val)
+    val.thisown = 1
+    return val
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+cvar = gdic.cvar
+wxNORMAL_FONT = wxFontPtr(gdic.cvar.wxNORMAL_FONT)
+wxSMALL_FONT = wxFontPtr(gdic.cvar.wxSMALL_FONT)
+wxITALIC_FONT = wxFontPtr(gdic.cvar.wxITALIC_FONT)
+wxSWISS_FONT = wxFontPtr(gdic.cvar.wxSWISS_FONT)
+wxRED_PEN = wxPenPtr(gdic.cvar.wxRED_PEN)
+wxCYAN_PEN = wxPenPtr(gdic.cvar.wxCYAN_PEN)
+wxGREEN_PEN = wxPenPtr(gdic.cvar.wxGREEN_PEN)
+wxBLACK_PEN = wxPenPtr(gdic.cvar.wxBLACK_PEN)
+wxWHITE_PEN = wxPenPtr(gdic.cvar.wxWHITE_PEN)
+wxTRANSPARENT_PEN = wxPenPtr(gdic.cvar.wxTRANSPARENT_PEN)
+wxBLACK_DASHED_PEN = wxPenPtr(gdic.cvar.wxBLACK_DASHED_PEN)
+wxGREY_PEN = wxPenPtr(gdic.cvar.wxGREY_PEN)
+wxMEDIUM_GREY_PEN = wxPenPtr(gdic.cvar.wxMEDIUM_GREY_PEN)
+wxLIGHT_GREY_PEN = wxPenPtr(gdic.cvar.wxLIGHT_GREY_PEN)
+wxBLUE_BRUSH = wxBrushPtr(gdic.cvar.wxBLUE_BRUSH)
+wxGREEN_BRUSH = wxBrushPtr(gdic.cvar.wxGREEN_BRUSH)
+wxWHITE_BRUSH = wxBrushPtr(gdic.cvar.wxWHITE_BRUSH)
+wxBLACK_BRUSH = wxBrushPtr(gdic.cvar.wxBLACK_BRUSH)
+wxTRANSPARENT_BRUSH = wxBrushPtr(gdic.cvar.wxTRANSPARENT_BRUSH)
+wxCYAN_BRUSH = wxBrushPtr(gdic.cvar.wxCYAN_BRUSH)
+wxRED_BRUSH = wxBrushPtr(gdic.cvar.wxRED_BRUSH)
+wxGREY_BRUSH = wxBrushPtr(gdic.cvar.wxGREY_BRUSH)
+wxMEDIUM_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxMEDIUM_GREY_BRUSH)
+wxLIGHT_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxLIGHT_GREY_BRUSH)
+wxBLACK = wxColourPtr(gdic.cvar.wxBLACK)
+wxWHITE = wxColourPtr(gdic.cvar.wxWHITE)
+wxRED = wxColourPtr(gdic.cvar.wxRED)
+wxBLUE = wxColourPtr(gdic.cvar.wxBLUE)
+wxGREEN = wxColourPtr(gdic.cvar.wxGREEN)
+wxCYAN = wxColourPtr(gdic.cvar.wxCYAN)
+wxLIGHT_GREY = wxColourPtr(gdic.cvar.wxLIGHT_GREY)
+wxSTANDARD_CURSOR = wxCursorPtr(gdic.cvar.wxSTANDARD_CURSOR)
+wxHOURGLASS_CURSOR = wxCursorPtr(gdic.cvar.wxHOURGLASS_CURSOR)
+wxCROSS_CURSOR = wxCursorPtr(gdic.cvar.wxCROSS_CURSOR)
+wxNullBitmap = wxBitmapPtr(gdic.cvar.wxNullBitmap)
+wxNullIcon = wxIconPtr(gdic.cvar.wxNullIcon)
+wxNullCursor = wxCursorPtr(gdic.cvar.wxNullCursor)
+wxNullPen = wxPenPtr(gdic.cvar.wxNullPen)
+wxNullBrush = wxBrushPtr(gdic.cvar.wxNullBrush)
+wxNullFont = wxFontPtr(gdic.cvar.wxNullFont)
+wxNullColour = wxColourPtr(gdic.cvar.wxNullColour)

utils/wxPython/src/msw/mdi.cpp

@@ -0,0 +1,995 @@
+/*
+ * FILE : msw/mdi.cpp
+ * 
+ * This file was automatically generated by :
+ * Simplified Wrapper and Interface Generator (SWIG)
+ * Version 1.1 (Patch 5)
+ * 
+ * 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,b) __declspec(dllexport) a b
+#   else
+#	if defined(__BORLANDC__)
+#	    define SWIGEXPORT(a,b) a _export b
+#	else
+#	    define SWIGEXPORT(a,b) a b
+#	endif
+#   endif
+#else
+#   define SWIGEXPORT(a,b) a b
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "Python.h"
+extern void SWIG_MakePtr(char *, void *, char *);
+extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
+extern char *SWIG_GetPtr(char *, void **, char *);
+extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
+extern PyObject *SWIG_newvarlink(void);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_init    initmdic
+
+#define SWIG_name    "mdic"
+
+#include "helpers.h"
+
+static PyObject* l_output_helper(PyObject* target, PyObject* o) {
+    PyObject*   o2;
+    if (!target) {
+        target = o;
+    } else if (target == Py_None) {
+        Py_DECREF(Py_None);
+        target = o;
+    } else {
+        if (!PyList_Check(target)) {
+            o2 = target;
+            target = PyList_New(0);
+            PyList_Append(target, o2);
+	    Py_XDECREF(o2);
+        }
+        PyList_Append(target,o);
+	Py_XDECREF(o);
+    }
+    return target;
+}
+
+static PyObject* t_output_helper(PyObject* target, PyObject* o) {
+    PyObject*   o2;
+    PyObject*   o3;
+
+    if (!target) {
+        target = o;
+    } else if (target == Py_None) {
+        Py_DECREF(Py_None);
+        target = o;
+    } else {
+        if (!PyTuple_Check(target)) {
+            o2 = target;
+            target = PyTuple_New(1);
+            PyTuple_SetItem(target, 0, o2);
+        }
+        o3 = PyTuple_New(1);
+        PyTuple_SetItem(o3, 0, o);
+
+        o2 = target;
+        target = PySequence_Concat(o2, o3);
+        Py_DECREF(o2);
+        Py_DECREF(o3);
+    }
+    return target;
+}
+
+
+extern byte* byte_LIST_helper(PyObject* source);
+extern int* int_LIST_helper(PyObject* source);
+extern long* long_LIST_helper(PyObject* source);
+extern char** string_LIST_helper(PyObject* source);
+extern wxPoint* wxPoint_LIST_helper(PyObject* source);
+extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
+extern wxString* wxString_LIST_helper(PyObject* source);
+extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+
+
+static char* wxStringErrorMsg = "string type is required for parameter";
+static void *SwigwxMDIParentFrameTowxFrame(void *ptr) {
+    wxMDIParentFrame *src;
+    wxFrame *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxFrame *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIParentFrameTowxWindow(void *ptr) {
+    wxMDIParentFrame *src;
+    wxWindow *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIParentFrameTowxEvtHandler(void *ptr) {
+    wxMDIParentFrame *src;
+    wxEvtHandler *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
+static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _result;
+    wxWindow * _arg0;
+    wxWindowID  _arg1;
+    wxString * _arg2;
+    wxPoint * _arg3 = &wxPyDefaultPosition;
+    wxSize * _arg4 = &wxPyDefaultSize;
+    long  _arg5 = (wxDEFAULT_FRAME_STYLE)|(wxVSCROLL)|(wxHSCROLL);
+    char * _arg6 = "frame";
+    char * _argc0 = 0;
+    PyObject * _obj2 = 0;
+    char * _argc3 = 0;
+    char * _argc4 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIParentFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIParentFrame. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+{
+    if (!PyString_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+        return NULL;
+    }
+    _arg2 = new wxString(PyString_AsString(_obj2));
+}
+    if (_argc3) {
+        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIParentFrame. Expected _wxPoint_p.");
+        return NULL;
+        }
+    }
+    if (_argc4) {
+        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIParentFrame. Expected _wxSize_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+{
+    if (_obj2)
+        delete _arg2;
+}
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ActivateNext(_swigobj)  (_swigobj->ActivateNext())
+static PyObject *_wrap_wxMDIParentFrame_ActivateNext(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivateNext",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivateNext. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ActivateNext(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ActivatePrevious(_swigobj)  (_swigobj->ActivatePrevious())
+static PyObject *_wrap_wxMDIParentFrame_ActivatePrevious(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivatePrevious",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivatePrevious. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ActivatePrevious(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ArrangeIcons(_swigobj)  (_swigobj->ArrangeIcons())
+static PyObject *_wrap_wxMDIParentFrame_ArrangeIcons(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ArrangeIcons",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ArrangeIcons. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ArrangeIcons(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_Cascade(_swigobj)  (_swigobj->Cascade())
+static PyObject *_wrap_wxMDIParentFrame_Cascade(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Cascade",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Cascade. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_Cascade(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIParentFrame_GetClientSize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    char * _argc0 = 0;
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientSize",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientSize. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_GetClientSize(_arg0,_arg1,_arg2);
+    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 wxMDIParentFrame_GetActiveChild(_swigobj)  (_swigobj->GetActiveChild())
+static PyObject *_wrap_wxMDIParentFrame_GetActiveChild(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetActiveChild",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetActiveChild. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetClientWindow(_swigobj)  (_swigobj->GetClientWindow())
+static PyObject *_wrap_wxMDIParentFrame_GetClientWindow(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIClientWindow * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientWindow",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientWindow. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetToolBar(_swigobj)  (_swigobj->GetToolBar())
+static PyObject *_wrap_wxMDIParentFrame_GetToolBar(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxWindow * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetToolBar",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetToolBar. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_SetToolBar(_swigobj,_swigarg0)  (_swigobj->SetToolBar(_swigarg0))
+static PyObject *_wrap_wxMDIParentFrame_SetToolBar(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    wxToolBar * _arg1;
+    char * _argc0 = 0;
+    char * _argc1 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"ss:wxMDIParentFrame_SetToolBar",&_argc0,&_argc1)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_SetToolBar. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    if (_argc1) {
+        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxToolBar_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIParentFrame_SetToolBar. Expected _wxToolBar_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_SetToolBar(_arg0,_arg1);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_Tile(_swigobj)  (_swigobj->Tile())
+static PyObject *_wrap_wxMDIParentFrame_Tile(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Tile",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Tile. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_Tile(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+static void *SwigwxMDIChildFrameTowxFrame(void *ptr) {
+    wxMDIChildFrame *src;
+    wxFrame *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxFrame *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIChildFrameTowxWindow(void *ptr) {
+    wxMDIChildFrame *src;
+    wxWindow *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIChildFrameTowxEvtHandler(void *ptr) {
+    wxMDIChildFrame *src;
+    wxEvtHandler *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
+static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _result;
+    wxMDIParentFrame * _arg0;
+    wxWindowID  _arg1;
+    wxString * _arg2;
+    wxPoint * _arg3 = &wxPyDefaultPosition;
+    wxSize * _arg4 = &wxPyDefaultSize;
+    long  _arg5 = (wxDEFAULT_FRAME_STYLE);
+    char * _arg6 = "frame";
+    char * _argc0 = 0;
+    PyObject * _obj2 = 0;
+    char * _argc3 = 0;
+    char * _argc4 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIChildFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIChildFrame. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+{
+    if (!PyString_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+        return NULL;
+    }
+    _arg2 = new wxString(PyString_AsString(_obj2));
+}
+    if (_argc3) {
+        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIChildFrame. Expected _wxPoint_p.");
+        return NULL;
+        }
+    }
+    if (_argc4) {
+        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIChildFrame. Expected _wxSize_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+{
+    if (_obj2)
+        delete _arg2;
+}
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Activate(_swigobj)  (_swigobj->Activate())
+static PyObject *_wrap_wxMDIChildFrame_Activate(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Activate",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Activate. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Activate(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Maximize(_swigobj)  (_swigobj->Maximize())
+static PyObject *_wrap_wxMDIChildFrame_Maximize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Maximize",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Maximize. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Maximize(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Restore(_swigobj)  (_swigobj->Restore())
+static PyObject *_wrap_wxMDIChildFrame_Restore(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Restore",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Restore. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Restore(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_SetMenuBar(_swigobj,_swigarg0)  (_swigobj->SetMenuBar(_swigarg0))
+static PyObject *_wrap_wxMDIChildFrame_SetMenuBar(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    wxMenuBar * _arg1;
+    char * _argc0 = 0;
+    char * _argc1 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"ss:wxMDIChildFrame_SetMenuBar",&_argc0,&_argc1)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetMenuBar. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    if (_argc1) {
+        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxMenuBar_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIChildFrame_SetMenuBar. Expected _wxMenuBar_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_SetMenuBar(_arg0,_arg1);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_SetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIChildFrame_SetClientSize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    int  _arg1;
+    int  _arg2;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"sii:wxMDIChildFrame_SetClientSize",&_argc0,&_arg1,&_arg2)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetClientSize. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_SetClientSize(_arg0,_arg1,_arg2);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_GetPosition(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetPosition(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIChildFrame_GetPosition(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    char * _argc0 = 0;
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_GetPosition",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_GetPosition. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_GetPosition(_arg0,_arg1,_arg2);
+    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;
+}
+
+static void *SwigwxMDIClientWindowTowxWindow(void *ptr) {
+    wxMDIClientWindow *src;
+    wxWindow *dest;
+    src = (wxMDIClientWindow *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIClientWindowTowxEvtHandler(void *ptr) {
+    wxMDIClientWindow *src;
+    wxEvtHandler *dest;
+    src = (wxMDIClientWindow *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIClientWindow(_swigarg0,_swigarg1) (new wxMDIClientWindow(_swigarg0,_swigarg1))
+static PyObject *_wrap_new_wxMDIClientWindow(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIClientWindow * _result;
+    wxMDIParentFrame * _arg0;
+    long  _arg1 = 0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s|l:new_wxMDIClientWindow",&_argc0,&_arg1)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIClientWindow. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+static PyMethodDef mdicMethods[] = {
+	 { "new_wxMDIClientWindow", _wrap_new_wxMDIClientWindow, 1 },
+	 { "wxMDIChildFrame_GetPosition", _wrap_wxMDIChildFrame_GetPosition, 1 },
+	 { "wxMDIChildFrame_SetClientSize", _wrap_wxMDIChildFrame_SetClientSize, 1 },
+	 { "wxMDIChildFrame_SetMenuBar", _wrap_wxMDIChildFrame_SetMenuBar, 1 },
+	 { "wxMDIChildFrame_Restore", _wrap_wxMDIChildFrame_Restore, 1 },
+	 { "wxMDIChildFrame_Maximize", _wrap_wxMDIChildFrame_Maximize, 1 },
+	 { "wxMDIChildFrame_Activate", _wrap_wxMDIChildFrame_Activate, 1 },
+	 { "new_wxMDIChildFrame", _wrap_new_wxMDIChildFrame, 1 },
+	 { "wxMDIParentFrame_Tile", _wrap_wxMDIParentFrame_Tile, 1 },
+	 { "wxMDIParentFrame_SetToolBar", _wrap_wxMDIParentFrame_SetToolBar, 1 },
+	 { "wxMDIParentFrame_GetToolBar", _wrap_wxMDIParentFrame_GetToolBar, 1 },
+	 { "wxMDIParentFrame_GetClientWindow", _wrap_wxMDIParentFrame_GetClientWindow, 1 },
+	 { "wxMDIParentFrame_GetActiveChild", _wrap_wxMDIParentFrame_GetActiveChild, 1 },
+	 { "wxMDIParentFrame_GetClientSize", _wrap_wxMDIParentFrame_GetClientSize, 1 },
+	 { "wxMDIParentFrame_Cascade", _wrap_wxMDIParentFrame_Cascade, 1 },
+	 { "wxMDIParentFrame_ArrangeIcons", _wrap_wxMDIParentFrame_ArrangeIcons, 1 },
+	 { "wxMDIParentFrame_ActivatePrevious", _wrap_wxMDIParentFrame_ActivatePrevious, 1 },
+	 { "wxMDIParentFrame_ActivateNext", _wrap_wxMDIParentFrame_ActivateNext, 1 },
+	 { "new_wxMDIParentFrame", _wrap_new_wxMDIParentFrame, 1 },
+	 { NULL, NULL }
+};
+static PyObject *SWIG_globals;
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT(void,initmdic)() {
+	 PyObject *m, *d;
+	 SWIG_globals = SWIG_newvarlink();
+	 m = Py_InitModule("mdic", mdicMethods);
+	 d = PyModule_GetDict(m);
+/*
+ * These are the pointer type-equivalency mappings. 
+ * (Used by the SWIG pointer type-checker).
+ */
+	 SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
+	 SWIG_RegisterMapping("_wxEvent","_class_wxEvent",0);
+	 SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
+	 SWIG_RegisterMapping("_signed_long","_long",0);
+	 SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
+	 SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
+	 SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
+	 SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
+	 SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
+	 SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
+	 SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
+	 SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
+	 SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
+	 SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
+	 SWIG_RegisterMapping("_byte","_unsigned_char",0);
+	 SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0);
+	 SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
+	 SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
+	 SWIG_RegisterMapping("_long","_wxDash",0);
+	 SWIG_RegisterMapping("_long","_unsigned_long",0);
+	 SWIG_RegisterMapping("_long","_signed_long",0);
+	 SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0);
+	 SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0);
+	 SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
+	 SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
+	 SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
+	 SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
+	 SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
+	 SWIG_RegisterMapping("_wxPrinterDC","_class_wxPrinterDC",0);
+	 SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
+	 SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0);
+	 SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0);
+	 SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0);
+	 SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
+	 SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0);
+	 SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0);
+	 SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0);
+	 SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
+	 SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0);
+	 SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
+	 SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
+	 SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
+	 SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
+	 SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
+	 SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
+	 SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
+	 SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
+	 SWIG_RegisterMapping("_uint","_unsigned_int",0);
+	 SWIG_RegisterMapping("_uint","_int",0);
+	 SWIG_RegisterMapping("_uint","_wxWindowID",0);
+	 SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
+	 SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
+	 SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
+	 SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
+	 SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0);
+	 SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
+	 SWIG_RegisterMapping("_class_wxButton","_wxButton",0);
+	 SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0);
+	 SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
+	 SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
+	 SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
+	 SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
+	 SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
+	 SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
+	 SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
+	 SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
+	 SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
+	 SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
+	 SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
+	 SWIG_RegisterMapping("_EBool","_signed_int",0);
+	 SWIG_RegisterMapping("_EBool","_int",0);
+	 SWIG_RegisterMapping("_EBool","_wxWindowID",0);
+	 SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
+	 SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0);
+	 SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
+	 SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
+	 SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
+	 SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
+	 SWIG_RegisterMapping("_unsigned_long","_long",0);
+	 SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
+	 SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
+	 SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0);
+	 SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
+	 SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0);
+	 SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxSpinButton","_wxSpinButton",0);
+	 SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
+	 SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
+	 SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
+	 SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
+	 SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
+	 SWIG_RegisterMapping("_signed_int","_EBool",0);
+	 SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_signed_int","_int",0);
+	 SWIG_RegisterMapping("_class_wxTextCtrl","_wxTextCtrl",0);
+	 SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
+	 SWIG_RegisterMapping("_wxMetaFileDC","_class_wxMetaFileDC",0);
+	 SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
+	 SWIG_RegisterMapping("_class_wxMoveEvent","_wxMoveEvent",0);
+	 SWIG_RegisterMapping("_wxListBox","_class_wxListBox",0);
+	 SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
+	 SWIG_RegisterMapping("_class_wxMDIChildFrame","_wxMDIChildFrame",0);
+	 SWIG_RegisterMapping("_WXTYPE","_short",0);
+	 SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
+	 SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
+	 SWIG_RegisterMapping("_class_wxMDIClientWindow","_wxMDIClientWindow",0);
+	 SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
+	 SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_unsigned_short","_short",0);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
+	 SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0);
+	 SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
+	 SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0);
+	 SWIG_RegisterMapping("_class_wxMenuEvent","_wxMenuEvent",0);
+	 SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
+	 SWIG_RegisterMapping("_wxMouseEvent","_class_wxMouseEvent",0);
+	 SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
+	 SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
+	 SWIG_RegisterMapping("_class_wxRadioBox","_wxRadioBox",0);
+	 SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_signed_short","_short",0);
+	 SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
+	 SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
+	 SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
+	 SWIG_RegisterMapping("_class_wxFocusEvent","_wxFocusEvent",0);
+	 SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0);
+	 SWIG_RegisterMapping("_wxStatusBar","_class_wxStatusBar",0);
+	 SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0);
+	 SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
+	 SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
+	 SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
+	 SWIG_RegisterMapping("_unsigned_char","_byte",0);
+	 SWIG_RegisterMapping("_class_wxMetaFileDC","_wxMetaFileDC",0);
+	 SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
+	 SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
+	 SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
+	 SWIG_RegisterMapping("_unsigned_int","_uint",0);
+	 SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_unsigned_int","_int",0);
+	 SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
+	 SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
+	 SWIG_RegisterMapping("_class_wxPyMenu","_wxPyMenu",0);
+	 SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
+	 SWIG_RegisterMapping("_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_short","_unsigned_short",0);
+	 SWIG_RegisterMapping("_short","_signed_short",0);
+	 SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0);
+	 SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
+	 SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
+	 SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0);
+	 SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
+	 SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
+	 SWIG_RegisterMapping("_wxWindowID","_EBool",0);
+	 SWIG_RegisterMapping("_wxWindowID","_uint",0);
+	 SWIG_RegisterMapping("_wxWindowID","_int",0);
+	 SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
+	 SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
+	 SWIG_RegisterMapping("_int","_EBool",0);
+	 SWIG_RegisterMapping("_int","_uint",0);
+	 SWIG_RegisterMapping("_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_int","_unsigned_int",0);
+	 SWIG_RegisterMapping("_int","_signed_int",0);
+	 SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0);
+	 SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0);
+	 SWIG_RegisterMapping("_wxButton","_class_wxButton",0);
+	 SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
+	 SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
+	 SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",0);
+	 SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0);
+	 SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
+	 SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0);
+	 SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0);
+	 SWIG_RegisterMapping("_class_wxComboBox","_wxComboBox",0);
+	 SWIG_RegisterMapping("_class_wxRadioButton","_wxRadioButton",0);
+	 SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
+	 SWIG_RegisterMapping("_wxIconizeEvent","_class_wxIconizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxControl","_wxControl",0);
+	 SWIG_RegisterMapping("_wxStaticBitmap","_class_wxStaticBitmap",0);
+	 SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
+	 SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
+	 SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
+	 SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
+	 SWIG_RegisterMapping("_class_wxIdleEvent","_wxIdleEvent",0);
+	 SWIG_RegisterMapping("_wxEraseEvent","_class_wxEraseEvent",0);
+	 SWIG_RegisterMapping("_class_wxJoystickEvent","_wxJoystickEvent",0);
+	 SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0);
+	 SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
+	 SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
+	 SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
+	 SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
+	 SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0);
+	 SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0);
+	 SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
+	 SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
+	 SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
+	 SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
+	 SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
+	 SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
+	 SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0);
+	 SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
+	 SWIG_RegisterMapping("_wxDash","_long",0);
+	 SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
+	 SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0);
+	 SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0);
+	 SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
+	 SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0);
+	 SWIG_RegisterMapping("_wxMDIClientWindow","_class_wxMDIClientWindow",0);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
+	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxFrame",0);
+}

utils/wxPython/src/msw/mdi.py

@@ -0,0 +1,134 @@
+# This file was created automatically by SWIG.
+import mdic
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from frames import *
+
+from stattool import *
+
+from controls import *
+
+from events import *
+import wx
+class wxMDIParentFramePtr(wxFramePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ActivateNext(self):
+        val = mdic.wxMDIParentFrame_ActivateNext(self.this)
+        return val
+    def ActivatePrevious(self):
+        val = mdic.wxMDIParentFrame_ActivatePrevious(self.this)
+        return val
+    def ArrangeIcons(self):
+        val = mdic.wxMDIParentFrame_ArrangeIcons(self.this)
+        return val
+    def Cascade(self):
+        val = mdic.wxMDIParentFrame_Cascade(self.this)
+        return val
+    def GetClientSize(self):
+        val = mdic.wxMDIParentFrame_GetClientSize(self.this)
+        return val
+    def GetActiveChild(self):
+        val = mdic.wxMDIParentFrame_GetActiveChild(self.this)
+        val = wxMDIChildFramePtr(val)
+        return val
+    def GetClientWindow(self):
+        val = mdic.wxMDIParentFrame_GetClientWindow(self.this)
+        val = wxMDIClientWindowPtr(val)
+        return val
+    def GetToolBar(self):
+        val = mdic.wxMDIParentFrame_GetToolBar(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def SetToolBar(self,arg0):
+        val = mdic.wxMDIParentFrame_SetToolBar(self.this,arg0.this)
+        return val
+    def Tile(self):
+        val = mdic.wxMDIParentFrame_Tile(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMDIParentFrame instance>"
+class wxMDIParentFrame(wxMDIParentFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(mdic.new_wxMDIParentFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+class wxMDIChildFramePtr(wxFramePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Activate(self):
+        val = mdic.wxMDIChildFrame_Activate(self.this)
+        return val
+    def Maximize(self):
+        val = mdic.wxMDIChildFrame_Maximize(self.this)
+        return val
+    def Restore(self):
+        val = mdic.wxMDIChildFrame_Restore(self.this)
+        return val
+    def SetMenuBar(self,arg0):
+        val = mdic.wxMDIChildFrame_SetMenuBar(self.this,arg0.this)
+        return val
+    def SetClientSize(self,arg0,arg1):
+        val = mdic.wxMDIChildFrame_SetClientSize(self.this,arg0,arg1)
+        return val
+    def GetPosition(self):
+        val = mdic.wxMDIChildFrame_GetPosition(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMDIChildFrame instance>"
+class wxMDIChildFrame(wxMDIChildFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(mdic.new_wxMDIChildFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+class wxMDIClientWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMDIClientWindow instance>"
+class wxMDIClientWindow(wxMDIClientWindowPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(mdic.new_wxMDIClientWindow,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._StdOnScrollCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/misc.py

@@ -0,0 +1,635 @@
+# This file was created automatically by SWIG.
+import miscc
+class wxSizePtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxSize(self.this)
+    def Set(self,arg0,arg1):
+        val = miscc.wxSize_Set(self.this,arg0,arg1)
+        return val
+    def GetWidth(self):
+        val = miscc.wxSize_GetWidth(self.this)
+        return val
+    def GetHeight(self):
+        val = miscc.wxSize_GetHeight(self.this)
+        return val
+    def __str__(self):
+        val = miscc.wxSize___str__(self.this)
+        return val
+    def __setattr__(self,name,value):
+        if name == "width" :
+            miscc.wxSize_width_set(self.this,value)
+            return
+        if name == "height" :
+            miscc.wxSize_height_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "width" : 
+            return miscc.wxSize_width_get(self.this)
+        if name == "height" : 
+            return miscc.wxSize_height_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxSize instance>"
+class wxSize(wxSizePtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxSize,()+args)
+        self.thisown = 1
+
+
+
+
+class wxRealPointPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRealPoint(self.this)
+    def __setattr__(self,name,value):
+        if name == "x" :
+            miscc.wxRealPoint_x_set(self.this,value)
+            return
+        if name == "y" :
+            miscc.wxRealPoint_y_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "x" : 
+            return miscc.wxRealPoint_x_get(self.this)
+        if name == "y" : 
+            return miscc.wxRealPoint_y_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxRealPoint instance>"
+class wxRealPoint(wxRealPointPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxRealPoint,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPointPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxPoint(self.this)
+    def Set(self,arg0,arg1):
+        val = miscc.wxPoint_Set(self.this,arg0,arg1)
+        return val
+    def __str__(self):
+        val = miscc.wxPoint___str__(self.this)
+        return val
+    def __setattr__(self,name,value):
+        if name == "x" :
+            miscc.wxPoint_x_set(self.this,value)
+            return
+        if name == "y" :
+            miscc.wxPoint_y_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "x" : 
+            return miscc.wxPoint_x_get(self.this)
+        if name == "y" : 
+            return miscc.wxPoint_y_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxPoint instance>"
+class wxPoint(wxPointPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxPoint,()+args)
+        self.thisown = 1
+
+
+
+
+class wxRectPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRect(self.this)
+    def GetX(self):
+        val = miscc.wxRect_GetX(self.this)
+        return val
+    def SetX(self,arg0):
+        val = miscc.wxRect_SetX(self.this,arg0)
+        return val
+    def GetY(self):
+        val = miscc.wxRect_GetY(self.this)
+        return val
+    def SetY(self,arg0):
+        val = miscc.wxRect_SetY(self.this,arg0)
+        return val
+    def GetWidth(self):
+        val = miscc.wxRect_GetWidth(self.this)
+        return val
+    def SetWidth(self,arg0):
+        val = miscc.wxRect_SetWidth(self.this,arg0)
+        return val
+    def GetHeight(self):
+        val = miscc.wxRect_GetHeight(self.this)
+        return val
+    def SetHeight(self,arg0):
+        val = miscc.wxRect_SetHeight(self.this,arg0)
+        return val
+    def GetPosition(self):
+        val = miscc.wxRect_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetSize(self):
+        val = miscc.wxRect_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetLeft(self):
+        val = miscc.wxRect_GetLeft(self.this)
+        return val
+    def GetTop(self):
+        val = miscc.wxRect_GetTop(self.this)
+        return val
+    def GetBottom(self):
+        val = miscc.wxRect_GetBottom(self.this)
+        return val
+    def GetRight(self):
+        val = miscc.wxRect_GetRight(self.this)
+        return val
+    def __setattr__(self,name,value):
+        if name == "x" :
+            miscc.wxRect_x_set(self.this,value)
+            return
+        if name == "y" :
+            miscc.wxRect_y_set(self.this,value)
+            return
+        if name == "width" :
+            miscc.wxRect_width_set(self.this,value)
+            return
+        if name == "height" :
+            miscc.wxRect_height_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "x" : 
+            return miscc.wxRect_x_get(self.this)
+        if name == "y" : 
+            return miscc.wxRect_y_get(self.this)
+        if name == "width" : 
+            return miscc.wxRect_width_get(self.this)
+        if name == "height" : 
+            return miscc.wxRect_height_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxRect instance>"
+class wxRect(wxRectPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxRect,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPyTimerPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxPyTimer(self.this)
+    def Interval(self):
+        val = miscc.wxPyTimer_Interval(self.this)
+        return val
+    def Start(self,*args):
+        val = apply(miscc.wxPyTimer_Start,(self.this,)+args)
+        return val
+    def Stop(self):
+        val = miscc.wxPyTimer_Stop(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPyTimer instance>"
+class wxPyTimer(wxPyTimerPtr):
+    def __init__(self,arg0) :
+        self.this = miscc.new_wxPyTimer(arg0)
+        self.thisown = 1
+
+
+
+
+class wxIndividualLayoutConstraintPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Above(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_Above,(self.this,arg0.this,)+args)
+        return val
+    def Absolute(self,arg0):
+        val = miscc.wxIndividualLayoutConstraint_Absolute(self.this,arg0)
+        return val
+    def AsIs(self):
+        val = miscc.wxIndividualLayoutConstraint_AsIs(self.this)
+        return val
+    def Below(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_Below,(self.this,arg0.this,)+args)
+        return val
+    def Unconstrained(self):
+        val = miscc.wxIndividualLayoutConstraint_Unconstrained(self.this)
+        return val
+    def LeftOf(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_LeftOf,(self.this,arg0.this,)+args)
+        return val
+    def PercentOf(self,arg0,arg1,arg2):
+        val = miscc.wxIndividualLayoutConstraint_PercentOf(self.this,arg0.this,arg1,arg2)
+        return val
+    def RightOf(self,arg0,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_RightOf,(self.this,arg0.this,)+args)
+        return val
+    def SameAs(self,arg0,arg1,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_SameAs,(self.this,arg0.this,arg1,)+args)
+        return val
+    def Set(self,arg0,arg1,arg2,*args):
+        val = apply(miscc.wxIndividualLayoutConstraint_Set,(self.this,arg0,arg1.this,arg2,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxIndividualLayoutConstraint instance>"
+class wxIndividualLayoutConstraint(wxIndividualLayoutConstraintPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxLayoutConstraintsPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __setattr__(self,name,value):
+        if name == "bottom" :
+            miscc.wxLayoutConstraints_bottom_set(self.this,value.this)
+            return
+        if name == "centreX" :
+            miscc.wxLayoutConstraints_centreX_set(self.this,value.this)
+            return
+        if name == "centreY" :
+            miscc.wxLayoutConstraints_centreY_set(self.this,value.this)
+            return
+        if name == "height" :
+            miscc.wxLayoutConstraints_height_set(self.this,value.this)
+            return
+        if name == "left" :
+            miscc.wxLayoutConstraints_left_set(self.this,value.this)
+            return
+        if name == "right" :
+            miscc.wxLayoutConstraints_right_set(self.this,value.this)
+            return
+        if name == "top" :
+            miscc.wxLayoutConstraints_top_set(self.this,value.this)
+            return
+        if name == "width" :
+            miscc.wxLayoutConstraints_width_set(self.this,value.this)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "bottom" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_bottom_get(self.this))
+        if name == "centreX" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreX_get(self.this))
+        if name == "centreY" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreY_get(self.this))
+        if name == "height" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_height_get(self.this))
+        if name == "left" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_left_get(self.this))
+        if name == "right" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_right_get(self.this))
+        if name == "top" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_top_get(self.this))
+        if name == "width" : 
+            return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_width_get(self.this))
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxLayoutConstraints instance>"
+class wxLayoutConstraints(wxLayoutConstraintsPtr):
+    def __init__(self) :
+        self.this = miscc.new_wxLayoutConstraints()
+        self.thisown = 1
+
+
+
+
+class wxRegionPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRegion(self.this)
+    def Clear(self):
+        val = miscc.wxRegion_Clear(self.this)
+        return val
+    def Contains(self,arg0,arg1):
+        val = miscc.wxRegion_Contains(self.this,arg0,arg1)
+        return val
+    def ContainsPoint(self,arg0):
+        val = miscc.wxRegion_ContainsPoint(self.this,arg0.this)
+        return val
+    def ContainsRect(self,arg0):
+        val = miscc.wxRegion_ContainsRect(self.this,arg0.this)
+        return val
+    def GetBox(self):
+        val = miscc.wxRegion_GetBox(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def Intersect(self,arg0):
+        val = miscc.wxRegion_Intersect(self.this,arg0.this)
+        return val
+    def IsEmpty(self):
+        val = miscc.wxRegion_IsEmpty(self.this)
+        return val
+    def Subtract(self,arg0):
+        val = miscc.wxRegion_Subtract(self.this,arg0.this)
+        return val
+    def Union(self,arg0):
+        val = miscc.wxRegion_Union(self.this,arg0.this)
+        return val
+    def Xor(self,arg0):
+        val = miscc.wxRegion_Xor(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxRegion instance>"
+class wxRegion(wxRegionPtr):
+    def __init__(self) :
+        self.this = miscc.new_wxRegion()
+        self.thisown = 1
+
+
+
+
+class wxRegionIteratorPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            miscc.delete_wxRegionIterator(self.this)
+    def GetX(self):
+        val = miscc.wxRegionIterator_GetX(self.this)
+        return val
+    def GetY(self):
+        val = miscc.wxRegionIterator_GetY(self.this)
+        return val
+    def GetW(self):
+        val = miscc.wxRegionIterator_GetW(self.this)
+        return val
+    def GetWidth(self):
+        val = miscc.wxRegionIterator_GetWidth(self.this)
+        return val
+    def GetH(self):
+        val = miscc.wxRegionIterator_GetH(self.this)
+        return val
+    def GetHeight(self):
+        val = miscc.wxRegionIterator_GetHeight(self.this)
+        return val
+    def GetRect(self):
+        val = miscc.wxRegionIterator_GetRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def HaveRects(self):
+        val = miscc.wxRegionIterator_HaveRects(self.this)
+        return val
+    def Reset(self):
+        val = miscc.wxRegionIterator_Reset(self.this)
+        return val
+    def Next(self):
+        val = miscc.wxRegionIterator_Next(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxRegionIterator instance>"
+class wxRegionIterator(wxRegionIteratorPtr):
+    def __init__(self,arg0) :
+        self.this = miscc.new_wxRegionIterator(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxAcceleratorEntryPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Set(self,arg0,arg1,arg2):
+        val = miscc.wxAcceleratorEntry_Set(self.this,arg0,arg1,arg2)
+        return val
+    def GetFlags(self):
+        val = miscc.wxAcceleratorEntry_GetFlags(self.this)
+        return val
+    def GetKeyCode(self):
+        val = miscc.wxAcceleratorEntry_GetKeyCode(self.this)
+        return val
+    def GetCommand(self):
+        val = miscc.wxAcceleratorEntry_GetCommand(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxAcceleratorEntry instance>"
+class wxAcceleratorEntry(wxAcceleratorEntryPtr):
+    def __init__(self,*args) :
+        self.this = apply(miscc.new_wxAcceleratorEntry,()+args)
+        self.thisown = 1
+
+
+
+
+class wxAcceleratorTablePtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxAcceleratorTable instance>"
+class wxAcceleratorTable(wxAcceleratorTablePtr):
+    def __init__(self,arg0) :
+        self.this = miscc.new_wxAcceleratorTable(arg0.this)
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+def wxFileSelector(arg0,*args):
+    argl = map(None,args)
+    try: argl[5] = argl[5].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxFileSelector,(arg0,)+args)
+    return val
+
+def wxGetTextFromUser(arg0,*args):
+    argl = map(None,args)
+    try: argl[2] = argl[2].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxGetTextFromUser,(arg0,)+args)
+    return val
+
+def wxGetSingleChoice(arg0,arg1,arg2,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxGetSingleChoice,(arg0,arg1,arg2,)+args)
+    return val
+
+def wxGetSingleChoiceIndex(arg0,arg1,arg2,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxGetSingleChoiceIndex,(arg0,arg1,arg2,)+args)
+    return val
+
+def wxMessageBox(arg0,*args):
+    argl = map(None,args)
+    try: argl[2] = argl[2].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxMessageBox,(arg0,)+args)
+    return val
+
+wxColourDisplay = miscc.wxColourDisplay
+
+wxDisplayDepth = miscc.wxDisplayDepth
+
+def wxSetCursor(arg0):
+    val = miscc.wxSetCursor(arg0.this)
+    return val
+
+NewId = miscc.NewId
+
+RegisterId = miscc.RegisterId
+
+def wxBeginBusyCursor(*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxBeginBusyCursor,()+args)
+    return val
+
+wxBell = miscc.wxBell
+
+wxDisplaySize = miscc.wxDisplaySize
+
+wxEndBusyCursor = miscc.wxEndBusyCursor
+
+wxExecute = miscc.wxExecute
+
+def wxFindWindowByLabel(arg0,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxFindWindowByLabel,(arg0,)+args)
+    val = wxWindowPtr(val)
+    return val
+
+def wxFindWindowByName(arg0,*args):
+    argl = map(None,args)
+    try: argl[0] = argl[0].this
+    except: pass
+    args = tuple(argl)
+    val = apply(miscc.wxFindWindowByName,(arg0,)+args)
+    val = wxWindowPtr(val)
+    return val
+
+def wxGetActiveWindow():
+    val = miscc.wxGetActiveWindow()
+    val = wxWindowPtr(val)
+    return val
+
+wxGetElapsedTime = miscc.wxGetElapsedTime
+
+wxGetFreeMemory = miscc.wxGetFreeMemory
+
+wxGetMousePosition = miscc.wxGetMousePosition
+
+wxIsBusy = miscc.wxIsBusy
+
+wxNow = miscc.wxNow
+
+wxShell = miscc.wxShell
+
+wxStartTimer = miscc.wxStartTimer
+
+wxGetOsVersion = miscc.wxGetOsVersion
+
+wxYield = miscc.wxYield
+
+wxGetResource = miscc.wxGetResource
+
+wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
+
+wxResourceClear = miscc.wxResourceClear
+
+def wxResourceCreateBitmap(arg0):
+    val = miscc.wxResourceCreateBitmap(arg0)
+    val = wxBitmapPtr(val)
+    val.thisown = 1
+    return val
+
+def wxResourceCreateIcon(arg0):
+    val = miscc.wxResourceCreateIcon(arg0)
+    val = wxIconPtr(val)
+    val.thisown = 1
+    return val
+
+def wxResourceCreateMenuBar(arg0):
+    val = miscc.wxResourceCreateMenuBar(arg0)
+    val = wxMenuBarPtr(val)
+    return val
+
+wxResourceGetIdentifier = miscc.wxResourceGetIdentifier
+
+wxResourceParseData = miscc.wxResourceParseData
+
+wxResourceParseFile = miscc.wxResourceParseFile
+
+wxResourceParseString = miscc.wxResourceParseString
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxLeft = miscc.wxLeft
+wxTop = miscc.wxTop
+wxRight = miscc.wxRight
+wxBottom = miscc.wxBottom
+wxWidth = miscc.wxWidth
+wxHeight = miscc.wxHeight
+wxCentre = miscc.wxCentre
+wxCenter = miscc.wxCenter
+wxCentreX = miscc.wxCentreX
+wxCentreY = miscc.wxCentreY
+wxUnconstrained = miscc.wxUnconstrained
+wxAsIs = miscc.wxAsIs
+wxPercentOf = miscc.wxPercentOf
+wxAbove = miscc.wxAbove
+wxBelow = miscc.wxBelow
+wxLeftOf = miscc.wxLeftOf
+wxRightOf = miscc.wxRightOf
+wxSameAs = miscc.wxSameAs
+wxAbsolute = miscc.wxAbsolute
+wxOutRegion = miscc.wxOutRegion
+wxPartRegion = miscc.wxPartRegion
+wxInRegion = miscc.wxInRegion

utils/wxPython/src/msw/stattool.py

@@ -0,0 +1,281 @@
+# This file was created automatically by SWIG.
+import stattoolc
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from controls import *
+
+from events import *
+import wx
+class wxStatusBarPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFieldRect(self,arg0):
+        val = stattoolc.wxStatusBar_GetFieldRect(self.this,arg0)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def GetFieldsCount(self):
+        val = stattoolc.wxStatusBar_GetFieldsCount(self.this)
+        return val
+    def GetStatusText(self,*args):
+        val = apply(stattoolc.wxStatusBar_GetStatusText,(self.this,)+args)
+        return val
+    def DrawField(self,arg0,arg1):
+        val = stattoolc.wxStatusBar_DrawField(self.this,arg0.this,arg1)
+        return val
+    def DrawFieldText(self,arg0,arg1):
+        val = stattoolc.wxStatusBar_DrawFieldText(self.this,arg0.this,arg1)
+        return val
+    def InitColours(self):
+        val = stattoolc.wxStatusBar_InitColours(self.this)
+        return val
+    def SetFieldsCount(self,*args):
+        val = apply(stattoolc.wxStatusBar_SetFieldsCount,(self.this,)+args)
+        return val
+    def SetStatusText(self,arg0,*args):
+        val = apply(stattoolc.wxStatusBar_SetStatusText,(self.this,arg0,)+args)
+        return val
+    def SetStatusWidths(self,arg0,*args):
+        val = apply(stattoolc.wxStatusBar_SetStatusWidths,(self.this,arg0,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxStatusBar instance>"
+class wxStatusBar(wxStatusBarPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(stattoolc.new_wxStatusBar,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxToolBarToolPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            stattoolc.delete_wxToolBarTool(self.this)
+    def SetSize(self,arg0,arg1):
+        val = stattoolc.wxToolBarTool_SetSize(self.this,arg0,arg1)
+        return val
+    def GetWidth(self):
+        val = stattoolc.wxToolBarTool_GetWidth(self.this)
+        return val
+    def GetHeight(self):
+        val = stattoolc.wxToolBarTool_GetHeight(self.this)
+        return val
+    def __setattr__(self,name,value):
+        if name == "m_toolStyle" :
+            stattoolc.wxToolBarTool_m_toolStyle_set(self.this,value)
+            return
+        if name == "m_clientData" :
+            stattoolc.wxToolBarTool_m_clientData_set(self.this,value)
+            return
+        if name == "m_index" :
+            stattoolc.wxToolBarTool_m_index_set(self.this,value)
+            return
+        if name == "m_x" :
+            stattoolc.wxToolBarTool_m_x_set(self.this,value)
+            return
+        if name == "m_y" :
+            stattoolc.wxToolBarTool_m_y_set(self.this,value)
+            return
+        if name == "m_width" :
+            stattoolc.wxToolBarTool_m_width_set(self.this,value)
+            return
+        if name == "m_height" :
+            stattoolc.wxToolBarTool_m_height_set(self.this,value)
+            return
+        if name == "m_toggleState" :
+            stattoolc.wxToolBarTool_m_toggleState_set(self.this,value)
+            return
+        if name == "m_isToggle" :
+            stattoolc.wxToolBarTool_m_isToggle_set(self.this,value)
+            return
+        if name == "m_deleteSecondBitmap" :
+            stattoolc.wxToolBarTool_m_deleteSecondBitmap_set(self.this,value)
+            return
+        if name == "m_enabled" :
+            stattoolc.wxToolBarTool_m_enabled_set(self.this,value)
+            return
+        if name == "m_bitmap1" :
+            stattoolc.wxToolBarTool_m_bitmap1_set(self.this,value.this)
+            return
+        if name == "m_bitmap2" :
+            stattoolc.wxToolBarTool_m_bitmap2_set(self.this,value.this)
+            return
+        if name == "m_isMenuCommand" :
+            stattoolc.wxToolBarTool_m_isMenuCommand_set(self.this,value)
+            return
+        if name == "m_shortHelpString" :
+            stattoolc.wxToolBarTool_m_shortHelpString_set(self.this,value)
+            return
+        if name == "m_longHelpString" :
+            stattoolc.wxToolBarTool_m_longHelpString_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_toolStyle" : 
+            return stattoolc.wxToolBarTool_m_toolStyle_get(self.this)
+        if name == "m_clientData" : 
+            return stattoolc.wxToolBarTool_m_clientData_get(self.this)
+        if name == "m_index" : 
+            return stattoolc.wxToolBarTool_m_index_get(self.this)
+        if name == "m_x" : 
+            return stattoolc.wxToolBarTool_m_x_get(self.this)
+        if name == "m_y" : 
+            return stattoolc.wxToolBarTool_m_y_get(self.this)
+        if name == "m_width" : 
+            return stattoolc.wxToolBarTool_m_width_get(self.this)
+        if name == "m_height" : 
+            return stattoolc.wxToolBarTool_m_height_get(self.this)
+        if name == "m_toggleState" : 
+            return stattoolc.wxToolBarTool_m_toggleState_get(self.this)
+        if name == "m_isToggle" : 
+            return stattoolc.wxToolBarTool_m_isToggle_get(self.this)
+        if name == "m_deleteSecondBitmap" : 
+            return stattoolc.wxToolBarTool_m_deleteSecondBitmap_get(self.this)
+        if name == "m_enabled" : 
+            return stattoolc.wxToolBarTool_m_enabled_get(self.this)
+        if name == "m_bitmap1" : 
+            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap1_get(self.this))
+        if name == "m_bitmap2" : 
+            return wxBitmapPtr(stattoolc.wxToolBarTool_m_bitmap2_get(self.this))
+        if name == "m_isMenuCommand" : 
+            return stattoolc.wxToolBarTool_m_isMenuCommand_get(self.this)
+        if name == "m_shortHelpString" : 
+            return stattoolc.wxToolBarTool_m_shortHelpString_get(self.this)
+        if name == "m_longHelpString" : 
+            return stattoolc.wxToolBarTool_m_longHelpString_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxToolBarTool instance>"
+class wxToolBarTool(wxToolBarToolPtr):
+    def __init__(self) :
+        self.this = stattoolc.new_wxToolBarTool()
+        self.thisown = 1
+
+
+
+
+class wxToolBarPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def AddSeparator(self):
+        val = stattoolc.wxToolBar_AddSeparator(self.this)
+        return val
+    def AddTool(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(stattoolc.wxToolBar_AddTool,(self.this,arg0,arg1.this,)+args)
+        val = wxToolBarToolPtr(val)
+        return val
+    def AddSimpleTool(self,arg0,arg1,*args):
+        val = apply(stattoolc.wxToolBar_AddSimpleTool,(self.this,arg0,arg1.this,)+args)
+        val = wxToolBarToolPtr(val)
+        return val
+    def EnableTool(self,arg0,arg1):
+        val = stattoolc.wxToolBar_EnableTool(self.this,arg0,arg1)
+        return val
+    def FindToolForPosition(self,arg0,arg1):
+        val = stattoolc.wxToolBar_FindToolForPosition(self.this,arg0,arg1)
+        val = wxToolBarToolPtr(val)
+        return val
+    def GetToolSize(self):
+        val = stattoolc.wxToolBar_GetToolSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetToolBitmapSize(self):
+        val = stattoolc.wxToolBar_GetToolBitmapSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def SetToolBitmapSize(self,arg0):
+        val = stattoolc.wxToolBar_SetToolBitmapSize(self.this,arg0.this)
+        return val
+    def GetMaxSize(self):
+        val = stattoolc.wxToolBar_GetMaxSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetToolEnabled(self,arg0):
+        val = stattoolc.wxToolBar_GetToolEnabled(self.this,arg0)
+        return val
+    def GetToolLongHelp(self,arg0):
+        val = stattoolc.wxToolBar_GetToolLongHelp(self.this,arg0)
+        return val
+    def GetToolPacking(self):
+        val = stattoolc.wxToolBar_GetToolPacking(self.this)
+        return val
+    def GetToolSeparation(self):
+        val = stattoolc.wxToolBar_GetToolSeparation(self.this)
+        return val
+    def GetToolShortHelp(self,arg0):
+        val = stattoolc.wxToolBar_GetToolShortHelp(self.this,arg0)
+        return val
+    def GetToolState(self,arg0):
+        val = stattoolc.wxToolBar_GetToolState(self.this,arg0)
+        return val
+    def Realize(self):
+        val = stattoolc.wxToolBar_Realize(self.this)
+        return val
+    def SetToolLongHelp(self,arg0,arg1):
+        val = stattoolc.wxToolBar_SetToolLongHelp(self.this,arg0,arg1)
+        return val
+    def SetToolShortHelp(self,arg0,arg1):
+        val = stattoolc.wxToolBar_SetToolShortHelp(self.this,arg0,arg1)
+        return val
+    def SetMargins(self,arg0):
+        val = stattoolc.wxToolBar_SetMargins(self.this,arg0.this)
+        return val
+    def SetToolPacking(self,arg0):
+        val = stattoolc.wxToolBar_SetToolPacking(self.this,arg0)
+        return val
+    def SetToolSeparation(self,arg0):
+        val = stattoolc.wxToolBar_SetToolSeparation(self.this,arg0)
+        return val
+    def ToggleTool(self,arg0,arg1):
+        val = stattoolc.wxToolBar_ToggleTool(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxToolBar instance>"
+class wxToolBar(wxToolBarPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(stattoolc.new_wxToolBar,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/utils.py

@@ -0,0 +1,114 @@
+# This file was created automatically by SWIG.
+import utilsc
+class wxConfigPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            utilsc.delete_wxConfig(self.this)
+    def DontCreateOnDemand(self):
+        val = utilsc.wxConfig_DontCreateOnDemand(self.this)
+        return val
+    def DeleteEntry(self,arg0,*args):
+        val = apply(utilsc.wxConfig_DeleteEntry,(self.this,arg0,)+args)
+        return val
+    def DeleteGroup(self,arg0):
+        val = utilsc.wxConfig_DeleteGroup(self.this,arg0)
+        return val
+    def Exists(self,arg0):
+        val = utilsc.wxConfig_Exists(self.this,arg0)
+        return val
+    def Flush(self,*args):
+        val = apply(utilsc.wxConfig_Flush,(self.this,)+args)
+        return val
+    def GetAppName(self):
+        val = utilsc.wxConfig_GetAppName(self.this)
+        return val
+    def GetFirstGroup(self):
+        val = utilsc.wxConfig_GetFirstGroup(self.this)
+        return val
+    def GetFirstEntry(self):
+        val = utilsc.wxConfig_GetFirstEntry(self.this)
+        return val
+    def GetNextGroup(self,arg0):
+        val = utilsc.wxConfig_GetNextGroup(self.this,arg0)
+        return val
+    def GetNextEntry(self,arg0):
+        val = utilsc.wxConfig_GetNextEntry(self.this,arg0)
+        return val
+    def GetNumberOfEntries(self,*args):
+        val = apply(utilsc.wxConfig_GetNumberOfEntries,(self.this,)+args)
+        return val
+    def GetNumberOfGroups(self,*args):
+        val = apply(utilsc.wxConfig_GetNumberOfGroups,(self.this,)+args)
+        return val
+    def GetPath(self):
+        val = utilsc.wxConfig_GetPath(self.this)
+        return val
+    def GetVendorName(self):
+        val = utilsc.wxConfig_GetVendorName(self.this)
+        return val
+    def HasEntry(self,arg0):
+        val = utilsc.wxConfig_HasEntry(self.this,arg0)
+        return val
+    def HasGroup(self,arg0):
+        val = utilsc.wxConfig_HasGroup(self.this,arg0)
+        return val
+    def IsExpandingEnvVars(self):
+        val = utilsc.wxConfig_IsExpandingEnvVars(self.this)
+        return val
+    def IsRecordingDefaults(self):
+        val = utilsc.wxConfig_IsRecordingDefaults(self.this)
+        return val
+    def Read(self,arg0,*args):
+        val = apply(utilsc.wxConfig_Read,(self.this,arg0,)+args)
+        return val
+    def ReadInt(self,arg0,*args):
+        val = apply(utilsc.wxConfig_ReadInt,(self.this,arg0,)+args)
+        return val
+    def ReadFloat(self,arg0,*args):
+        val = apply(utilsc.wxConfig_ReadFloat,(self.this,arg0,)+args)
+        return val
+    def SetAppName(self,arg0):
+        val = utilsc.wxConfig_SetAppName(self.this,arg0)
+        return val
+    def SetExpandEnvVars(self,*args):
+        val = apply(utilsc.wxConfig_SetExpandEnvVars,(self.this,)+args)
+        return val
+    def SetPath(self,arg0):
+        val = utilsc.wxConfig_SetPath(self.this,arg0)
+        return val
+    def SetRecordDefaults(self,*args):
+        val = apply(utilsc.wxConfig_SetRecordDefaults,(self.this,)+args)
+        return val
+    def SetVendorName(self,arg0):
+        val = utilsc.wxConfig_SetVendorName(self.this,arg0)
+        return val
+    def Write(self,arg0,arg1):
+        val = utilsc.wxConfig_Write(self.this,arg0,arg1)
+        return val
+    def WriteInt(self,arg0,arg1):
+        val = utilsc.wxConfig_WriteInt(self.this,arg0,arg1)
+        return val
+    def WriteFloat(self,arg0,arg1):
+        val = utilsc.wxConfig_WriteFloat(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxConfig instance>"
+class wxConfig(wxConfigPtr):
+    def __init__(self,*args) :
+        self.this = apply(utilsc.new_wxConfig,()+args)
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/windows.py

@@ -0,0 +1,663 @@
+# This file was created automatically by SWIG.
+import windowsc
+
+from misc import *
+
+from gdi import *
+import wx
+
+def wxDLG_PNT(win, point):
+    return win.ConvertDialogPointToPixels(point)
+
+def wxDLG_SZE(win, size):
+    return win.ConvertDialogPointToPixels(size)
+
+class wxEvtHandlerPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Connect(self,arg0,arg1,arg2,arg3):
+        val = windowsc.wxEvtHandler_Connect(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def __repr__(self):
+        return "<C wxEvtHandler instance>"
+class wxEvtHandler(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxWindowPtr(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def CaptureMouse(self):
+        val = windowsc.wxWindow_CaptureMouse(self.this)
+        return val
+    def Center(self,*args):
+        val = apply(windowsc.wxWindow_Center,(self.this,)+args)
+        return val
+    def Centre(self,*args):
+        val = apply(windowsc.wxWindow_Centre,(self.this,)+args)
+        return val
+    def ClientToScreen(self,arg0,arg1):
+        val = windowsc.wxWindow_ClientToScreen(self.this,arg0,arg1)
+        return val
+    def Close(self,*args):
+        val = apply(windowsc.wxWindow_Close,(self.this,)+args)
+        return val
+    def Destroy(self):
+        val = windowsc.wxWindow_Destroy(self.this)
+        return val
+    def DestroyChildren(self):
+        val = windowsc.wxWindow_DestroyChildren(self.this)
+        return val
+    def DragAcceptFiles(self,arg0):
+        val = windowsc.wxWindow_DragAcceptFiles(self.this,arg0)
+        return val
+    def Enable(self,arg0):
+        val = windowsc.wxWindow_Enable(self.this,arg0)
+        return val
+    def FindWindowByID(self,arg0):
+        val = windowsc.wxWindow_FindWindowByID(self.this,arg0)
+        val = wxWindowPtr(val)
+        return val
+    def FindWindowByName(self,arg0):
+        val = windowsc.wxWindow_FindWindowByName(self.this,arg0)
+        val = wxWindowPtr(val)
+        return val
+    def Fit(self):
+        val = windowsc.wxWindow_Fit(self.this)
+        return val
+    def GetBackgroundColour(self):
+        val = windowsc.wxWindow_GetBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def GetCharHeight(self):
+        val = windowsc.wxWindow_GetCharHeight(self.this)
+        return val
+    def GetCharWidth(self):
+        val = windowsc.wxWindow_GetCharWidth(self.this)
+        return val
+    def GetClientSizeTuple(self):
+        val = windowsc.wxWindow_GetClientSizeTuple(self.this)
+        return val
+    def GetClientSize(self):
+        val = windowsc.wxWindow_GetClientSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetConstraints(self):
+        val = windowsc.wxWindow_GetConstraints(self.this)
+        val = wxLayoutConstraintsPtr(val)
+        return val
+    def GetDefaultItem(self):
+        val = windowsc.wxWindow_GetDefaultItem(self.this)
+        val = wxButtonPtr(val)
+        return val
+    def GetFont(self):
+        val = windowsc.wxWindow_GetFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetForegroundColour(self):
+        val = windowsc.wxWindow_GetForegroundColour(self.this)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def GetGrandParent(self):
+        val = windowsc.wxWindow_GetGrandParent(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def GetId(self):
+        val = windowsc.wxWindow_GetId(self.this)
+        return val
+    def GetLabel(self):
+        val = windowsc.wxWindow_GetLabel(self.this)
+        return val
+    def GetName(self):
+        val = windowsc.wxWindow_GetName(self.this)
+        return val
+    def GetParent(self):
+        val = windowsc.wxWindow_GetParent(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def GetPositionTuple(self):
+        val = windowsc.wxWindow_GetPositionTuple(self.this)
+        return val
+    def GetPosition(self):
+        val = windowsc.wxWindow_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetRect(self):
+        val = windowsc.wxWindow_GetRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def GetReturnCode(self):
+        val = windowsc.wxWindow_GetReturnCode(self.this)
+        return val
+    def GetScrollThumb(self,arg0):
+        val = windowsc.wxWindow_GetScrollThumb(self.this,arg0)
+        return val
+    def GetScrollPos(self,arg0):
+        val = windowsc.wxWindow_GetScrollPos(self.this,arg0)
+        return val
+    def GetScrollRange(self,arg0):
+        val = windowsc.wxWindow_GetScrollRange(self.this,arg0)
+        return val
+    def GetSizeTuple(self):
+        val = windowsc.wxWindow_GetSizeTuple(self.this)
+        return val
+    def GetSize(self):
+        val = windowsc.wxWindow_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def GetTextExtent(self,arg0):
+        val = windowsc.wxWindow_GetTextExtent(self.this,arg0)
+        return val
+    def GetTitle(self):
+        val = windowsc.wxWindow_GetTitle(self.this)
+        return val
+    def GetWindowStyleFlag(self):
+        val = windowsc.wxWindow_GetWindowStyleFlag(self.this)
+        return val
+    def InitDialog(self):
+        val = windowsc.wxWindow_InitDialog(self.this)
+        return val
+    def IsEnabled(self):
+        val = windowsc.wxWindow_IsEnabled(self.this)
+        return val
+    def IsRetained(self):
+        val = windowsc.wxWindow_IsRetained(self.this)
+        return val
+    def IsShown(self):
+        val = windowsc.wxWindow_IsShown(self.this)
+        return val
+    def Layout(self):
+        val = windowsc.wxWindow_Layout(self.this)
+        return val
+    def LoadFromResource(self,arg0,arg1,*args):
+        val = apply(windowsc.wxWindow_LoadFromResource,(self.this,arg0.this,arg1,)+args)
+        return val
+    def Lower(self):
+        val = windowsc.wxWindow_Lower(self.this)
+        return val
+    def MakeModal(self,arg0):
+        val = windowsc.wxWindow_MakeModal(self.this,arg0)
+        return val
+    def Move(self,arg0,arg1):
+        val = windowsc.wxWindow_Move(self.this,arg0,arg1)
+        return val
+    def PopupMenu(self,arg0,arg1,arg2):
+        val = windowsc.wxWindow_PopupMenu(self.this,arg0.this,arg1,arg2)
+        return val
+    def Raise(self):
+        val = windowsc.wxWindow_Raise(self.this)
+        return val
+    def Refresh(self,*args):
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windowsc.wxWindow_Refresh,(self.this,)+args)
+        return val
+    def ReleaseMouse(self):
+        val = windowsc.wxWindow_ReleaseMouse(self.this)
+        return val
+    def ScreenToClient(self,arg0,arg1):
+        val = windowsc.wxWindow_ScreenToClient(self.this,arg0,arg1)
+        return val
+    def ScrollWindow(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windowsc.wxWindow_ScrollWindow,(self.this,arg0,arg1,)+args)
+        return val
+    def SetAcceleratorTable(self,arg0):
+        val = windowsc.wxWindow_SetAcceleratorTable(self.this,arg0.this)
+        return val
+    def SetAutoLayout(self,arg0):
+        val = windowsc.wxWindow_SetAutoLayout(self.this,arg0)
+        return val
+    def SetBackgroundColour(self,arg0):
+        val = windowsc.wxWindow_SetBackgroundColour(self.this,arg0.this)
+        return val
+    def SetConstraints(self,arg0):
+        val = windowsc.wxWindow_SetConstraints(self.this,arg0.this)
+        return val
+    def SetDoubleClick(self,arg0):
+        val = windowsc.wxWindow_SetDoubleClick(self.this,arg0)
+        return val
+    def SetFocus(self):
+        val = windowsc.wxWindow_SetFocus(self.this)
+        return val
+    def SetFont(self,arg0):
+        val = windowsc.wxWindow_SetFont(self.this,arg0.this)
+        return val
+    def SetForegroundColour(self,arg0):
+        val = windowsc.wxWindow_SetForegroundColour(self.this,arg0.this)
+        return val
+    def SetId(self,arg0):
+        val = windowsc.wxWindow_SetId(self.this,arg0)
+        return val
+    def SetName(self,arg0):
+        val = windowsc.wxWindow_SetName(self.this,arg0)
+        return val
+    def SetReturnCode(self,arg0):
+        val = windowsc.wxWindow_SetReturnCode(self.this,arg0)
+        return val
+    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(windowsc.wxWindow_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def SetScrollPos(self,arg0,arg1,*args):
+        val = apply(windowsc.wxWindow_SetScrollPos,(self.this,arg0,arg1,)+args)
+        return val
+    def SetDimensions(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(windowsc.wxWindow_SetDimensions,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def SetSize(self,arg0):
+        val = windowsc.wxWindow_SetSize(self.this,arg0.this)
+        return val
+    def SetPosition(self,arg0):
+        val = windowsc.wxWindow_SetPosition(self.this,arg0.this)
+        return val
+    def SetSizeHints(self,*args):
+        val = apply(windowsc.wxWindow_SetSizeHints,(self.this,)+args)
+        return val
+    def SetClientSize(self,arg0,arg1):
+        val = windowsc.wxWindow_SetClientSize(self.this,arg0,arg1)
+        return val
+    def SetCursor(self,arg0):
+        val = windowsc.wxWindow_SetCursor(self.this,arg0.this)
+        return val
+    def SetTitle(self,arg0):
+        val = windowsc.wxWindow_SetTitle(self.this,arg0)
+        return val
+    def Show(self,arg0):
+        val = windowsc.wxWindow_Show(self.this,arg0)
+        return val
+    def TransferDataFromWindow(self):
+        val = windowsc.wxWindow_TransferDataFromWindow(self.this)
+        return val
+    def TransferDataToWindow(self):
+        val = windowsc.wxWindow_TransferDataToWindow(self.this)
+        return val
+    def Validate(self):
+        val = windowsc.wxWindow_Validate(self.this)
+        return val
+    def WarpPointer(self,arg0,arg1):
+        val = windowsc.wxWindow_WarpPointer(self.this,arg0,arg1)
+        return val
+    def ConvertDialogPointToPixels(self,arg0):
+        val = windowsc.wxWindow_ConvertDialogPointToPixels(self.this,arg0.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def ConvertDialogSizeToPixels(self,arg0):
+        val = windowsc.wxWindow_ConvertDialogSizeToPixels(self.this,arg0.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def ConvertPixelPointToDialog(self,arg0):
+        val = windowsc.wxWindow_ConvertPixelPointToDialog(self.this,arg0.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def ConvertPixelSizeToDialog(self,arg0):
+        val = windowsc.wxWindow_ConvertPixelSizeToDialog(self.this,arg0.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxWindow instance>"
+class wxWindow(wxWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxPanelPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def InitDialog(self):
+        val = windowsc.wxPanel_InitDialog(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPanel instance>"
+class wxPanel(wxPanelPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxPanel,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxDialogPtr(wxPanelPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Centre(self,*args):
+        val = apply(windowsc.wxDialog_Centre,(self.this,)+args)
+        return val
+    def EndModal(self,arg0):
+        val = windowsc.wxDialog_EndModal(self.this,arg0)
+        return val
+    def GetTitle(self):
+        val = windowsc.wxDialog_GetTitle(self.this)
+        return val
+    def Iconize(self,arg0):
+        val = windowsc.wxDialog_Iconize(self.this,arg0)
+        return val
+    def IsIconized(self):
+        val = windowsc.wxDialog_IsIconized(self.this)
+        return val
+    def SetModal(self,arg0):
+        val = windowsc.wxDialog_SetModal(self.this,arg0)
+        return val
+    def IsModal(self):
+        val = windowsc.wxDialog_IsModal(self.this)
+        return val
+    def SetTitle(self,arg0):
+        val = windowsc.wxDialog_SetTitle(self.this,arg0)
+        return val
+    def Show(self,arg0):
+        val = windowsc.wxDialog_Show(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = windowsc.wxDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDialog instance>"
+class wxDialog(wxDialogPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxDialog,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxScrolledWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def EnableScrolling(self,arg0,arg1):
+        val = windowsc.wxScrolledWindow_EnableScrolling(self.this,arg0,arg1)
+        return val
+    def GetScrollPixelsPerUnit(self):
+        val = windowsc.wxScrolledWindow_GetScrollPixelsPerUnit(self.this)
+        return val
+    def GetVirtualSize(self):
+        val = windowsc.wxScrolledWindow_GetVirtualSize(self.this)
+        return val
+    def IsRetained(self):
+        val = windowsc.wxScrolledWindow_IsRetained(self.this)
+        return val
+    def PrepareDC(self,arg0):
+        val = windowsc.wxScrolledWindow_PrepareDC(self.this,arg0.this)
+        return val
+    def Scroll(self,arg0,arg1):
+        val = windowsc.wxScrolledWindow_Scroll(self.this,arg0,arg1)
+        return val
+    def SetScrollbars(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(windowsc.wxScrolledWindow_SetScrollbars,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def ViewStart(self):
+        val = windowsc.wxScrolledWindow_ViewStart(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScrolledWindow instance>"
+class wxScrolledWindow(wxScrolledWindowPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windowsc.new_wxScrolledWindow,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._StdOnScrollCallbacks(self)
+
+
+
+
+class wxMenuPtr(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0,arg1,*args):
+        val = apply(windowsc.wxMenu_Append,(self.this,arg0,arg1,)+args)
+        return val
+    def AppendMenu(self,arg0,arg1,arg2,*args):
+        val = apply(windowsc.wxMenu_AppendMenu,(self.this,arg0,arg1,arg2.this,)+args)
+        return val
+    def AppendSeparator(self):
+        val = windowsc.wxMenu_AppendSeparator(self.this)
+        return val
+    def Break(self):
+        val = windowsc.wxMenu_Break(self.this)
+        return val
+    def Check(self,arg0,arg1):
+        val = windowsc.wxMenu_Check(self.this,arg0,arg1)
+        return val
+    def Enable(self,arg0,arg1):
+        val = windowsc.wxMenu_Enable(self.this,arg0,arg1)
+        return val
+    def FindItem(self,arg0):
+        val = windowsc.wxMenu_FindItem(self.this,arg0)
+        return val
+    def GetTitle(self):
+        val = windowsc.wxMenu_GetTitle(self.this)
+        return val
+    def SetTitle(self,arg0):
+        val = windowsc.wxMenu_SetTitle(self.this,arg0)
+        return val
+    def FindItemForId(self,arg0):
+        val = windowsc.wxMenu_FindItemForId(self.this,arg0)
+        val = wxMenuItemPtr(val)
+        return val
+    def GetHelpString(self,arg0):
+        val = windowsc.wxMenu_GetHelpString(self.this,arg0)
+        return val
+    def GetLabel(self,arg0):
+        val = windowsc.wxMenu_GetLabel(self.this,arg0)
+        return val
+    def SetHelpString(self,arg0,arg1):
+        val = windowsc.wxMenu_SetHelpString(self.this,arg0,arg1)
+        return val
+    def IsChecked(self,arg0):
+        val = windowsc.wxMenu_IsChecked(self.this,arg0)
+        return val
+    def IsEnabled(self,arg0):
+        val = windowsc.wxMenu_IsEnabled(self.this,arg0)
+        return val
+    def SetLabel(self,arg0,arg1):
+        val = windowsc.wxMenu_SetLabel(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxMenu instance>"
+class wxMenu(wxMenuPtr):
+    def __init__(self,*args) :
+        self.this = apply(windowsc.new_wxMenu,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPyMenuPtr(wxMenuPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            windowsc.delete_wxPyMenu(self.this)
+    def __repr__(self):
+        return "<C wxPyMenu instance>"
+class wxPyMenu(wxPyMenuPtr):
+    def __init__(self,*args) :
+        self.this = apply(windowsc.new_wxPyMenu,()+args)
+        self.thisown = 1
+
+
+
+
+class wxMenuBarPtr(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0,arg1):
+        val = windowsc.wxMenuBar_Append(self.this,arg0.this,arg1)
+        return val
+    def Check(self,arg0,arg1):
+        val = windowsc.wxMenuBar_Check(self.this,arg0,arg1)
+        return val
+    def Checked(self,arg0):
+        val = windowsc.wxMenuBar_Checked(self.this,arg0)
+        return val
+    def Enable(self,arg0,arg1):
+        val = windowsc.wxMenuBar_Enable(self.this,arg0,arg1)
+        return val
+    def Enabled(self,arg0):
+        val = windowsc.wxMenuBar_Enabled(self.this,arg0)
+        return val
+    def FindMenuItem(self,arg0,arg1):
+        val = windowsc.wxMenuBar_FindMenuItem(self.this,arg0,arg1)
+        return val
+    def FindItemForId(self,arg0):
+        val = windowsc.wxMenuBar_FindItemForId(self.this,arg0)
+        val = wxMenuItemPtr(val)
+        return val
+    def EnableTop(self,arg0,arg1):
+        val = windowsc.wxMenuBar_EnableTop(self.this,arg0,arg1)
+        return val
+    def GetHelpString(self,arg0):
+        val = windowsc.wxMenuBar_GetHelpString(self.this,arg0)
+        return val
+    def GetLabel(self,arg0):
+        val = windowsc.wxMenuBar_GetLabel(self.this,arg0)
+        return val
+    def SetHelpString(self,arg0,arg1):
+        val = windowsc.wxMenuBar_SetHelpString(self.this,arg0,arg1)
+        return val
+    def SetLabel(self,arg0,arg1):
+        val = windowsc.wxMenuBar_SetLabel(self.this,arg0,arg1)
+        return val
+    def GetLabelTop(self,arg0):
+        val = windowsc.wxMenuBar_GetLabelTop(self.this,arg0)
+        return val
+    def SetLabelTop(self,arg0,arg1):
+        val = windowsc.wxMenuBar_SetLabelTop(self.this,arg0,arg1)
+        return val
+    def GetMenuCount(self):
+        val = windowsc.wxMenuBar_GetMenuCount(self.this)
+        return val
+    def GetMenu(self,arg0):
+        val = windowsc.wxMenuBar_GetMenu(self.this,arg0)
+        val = wxMenuPtr(val)
+        return val
+    def __repr__(self):
+        return "<C wxMenuBar instance>"
+class wxMenuBar(wxMenuBarPtr):
+    def __init__(self) :
+        self.this = windowsc.new_wxMenuBar()
+        self.thisown = 1
+
+
+
+
+class wxMenuItemPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsSeparator(self):
+        val = windowsc.wxMenuItem_IsSeparator(self.this)
+        return val
+    def IsEnabled(self):
+        val = windowsc.wxMenuItem_IsEnabled(self.this)
+        return val
+    def IsChecked(self):
+        val = windowsc.wxMenuItem_IsChecked(self.this)
+        return val
+    def IsCheckable(self):
+        val = windowsc.wxMenuItem_IsCheckable(self.this)
+        return val
+    def GetId(self):
+        val = windowsc.wxMenuItem_GetId(self.this)
+        return val
+    def GetSubMenu(self):
+        val = windowsc.wxMenuItem_GetSubMenu(self.this)
+        val = wxMenuPtr(val)
+        return val
+    def SetName(self,arg0):
+        val = windowsc.wxMenuItem_SetName(self.this,arg0)
+        return val
+    def GetName(self):
+        val = windowsc.wxMenuItem_GetName(self.this)
+        return val
+    def GetHelp(self):
+        val = windowsc.wxMenuItem_GetHelp(self.this)
+        return val
+    def SetHelp(self,arg0):
+        val = windowsc.wxMenuItem_SetHelp(self.this,arg0)
+        return val
+    def Enable(self,*args):
+        val = apply(windowsc.wxMenuItem_Enable,(self.this,)+args)
+        return val
+    def Check(self,*args):
+        val = apply(windowsc.wxMenuItem_Check,(self.this,)+args)
+        return val
+    def DeleteSubMenu(self):
+        val = windowsc.wxMenuItem_DeleteSubMenu(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMenuItem instance>"
+class wxMenuItem(wxMenuItemPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+def wxWindow_FindFocus():
+    val = windowsc.wxWindow_FindFocus()
+    val = wxWindowPtr(val)
+    return val
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/msw/windows2.py

@@ -0,0 +1,588 @@
+# This file was created automatically by SWIG.
+import windows2c
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+
+from controls import *
+
+from events import *
+import wx
+class wxGridCellPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            windows2c.delete_wxGridCell(self.this)
+    def GetTextValue(self):
+        val = windows2c.wxGridCell_GetTextValue(self.this)
+        return val
+    def SetTextValue(self,arg0):
+        val = windows2c.wxGridCell_SetTextValue(self.this,arg0)
+        return val
+    def GetFont(self):
+        val = windows2c.wxGridCell_GetFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def SetFont(self,arg0):
+        val = windows2c.wxGridCell_SetFont(self.this,arg0.this)
+        return val
+    def GetTextColour(self):
+        val = windows2c.wxGridCell_GetTextColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def SetTextColour(self,arg0):
+        val = windows2c.wxGridCell_SetTextColour(self.this,arg0.this)
+        return val
+    def GetBackgroundColour(self):
+        val = windows2c.wxGridCell_GetBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def SetBackgroundColour(self,arg0):
+        val = windows2c.wxGridCell_SetBackgroundColour(self.this,arg0.this)
+        return val
+    def GetBackgroundBrush(self):
+        val = windows2c.wxGridCell_GetBackgroundBrush(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetAlignment(self):
+        val = windows2c.wxGridCell_GetAlignment(self.this)
+        return val
+    def SetAlignment(self,arg0):
+        val = windows2c.wxGridCell_SetAlignment(self.this,arg0)
+        return val
+    def GetCellBitmap(self):
+        val = windows2c.wxGridCell_GetCellBitmap(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetCellBitmap(self,arg0):
+        val = windows2c.wxGridCell_SetCellBitmap(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxGridCell instance>"
+class wxGridCell(wxGridCellPtr):
+    def __init__(self) :
+        self.this = windows2c.new_wxGridCell()
+        self.thisown = 1
+
+
+
+
+class wxGridPtr(wxPanelPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def AdjustScrollbars(self):
+        val = windows2c.wxGrid_AdjustScrollbars(self.this)
+        return val
+    def AppendCols(self,*args):
+        val = apply(windows2c.wxGrid_AppendCols,(self.this,)+args)
+        return val
+    def AppendRows(self,*args):
+        val = apply(windows2c.wxGrid_AppendRows,(self.this,)+args)
+        return val
+    def BeginBatch(self):
+        val = windows2c.wxGrid_BeginBatch(self.this)
+        return val
+    def CellHitTest(self,arg0,arg1):
+        val = windows2c.wxGrid_CellHitTest(self.this,arg0,arg1)
+        return val
+    def CreateGrid(self,arg0,arg1,*args):
+        val = apply(windows2c.wxGrid_CreateGrid,(self.this,arg0,arg1,)+args)
+        return val
+    def CurrentCellVisible(self):
+        val = windows2c.wxGrid_CurrentCellVisible(self.this)
+        return val
+    def DeleteCols(self,*args):
+        val = apply(windows2c.wxGrid_DeleteCols,(self.this,)+args)
+        return val
+    def DeleteRows(self,*args):
+        val = apply(windows2c.wxGrid_DeleteRows,(self.this,)+args)
+        return val
+    def EndBatch(self):
+        val = windows2c.wxGrid_EndBatch(self.this)
+        return val
+    def GetBatchCount(self):
+        val = windows2c.wxGrid_GetBatchCount(self.this)
+        return val
+    def GetCell(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCell(self.this,arg0,arg1)
+        val = wxGridCellPtr(val)
+        return val
+    def GetCellAlignment(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellAlignment(self.this,arg0,arg1)
+        return val
+    def GetDefCellAlignment(self):
+        val = windows2c.wxGrid_GetDefCellAlignment(self.this)
+        return val
+    def GetCellBackgroundColour(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellBackgroundColour(self.this,arg0,arg1)
+        val = wxColourPtr(val)
+        return val
+    def GetDefCellBackgroundColour(self):
+        val = windows2c.wxGrid_GetDefCellBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetCellTextColour(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellTextColour(self.this,arg0,arg1)
+        val = wxColourPtr(val)
+        return val
+    def GetDefCellTextColour(self):
+        val = windows2c.wxGrid_GetDefCellTextColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetCellTextFont(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellTextFont(self.this,arg0,arg1)
+        val = wxFontPtr(val)
+        return val
+    def GetDefCellTextFont(self):
+        val = windows2c.wxGrid_GetDefCellTextFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetCellValue(self,arg0,arg1):
+        val = windows2c.wxGrid_GetCellValue(self.this,arg0,arg1)
+        return val
+    def GetCols(self):
+        val = windows2c.wxGrid_GetCols(self.this)
+        return val
+    def GetColumnWidth(self,arg0):
+        val = windows2c.wxGrid_GetColumnWidth(self.this,arg0)
+        return val
+    def GetCurrentRect(self):
+        val = windows2c.wxGrid_GetCurrentRect(self.this)
+        val = wxRectPtr(val)
+        return val
+    def GetCursorColumn(self):
+        val = windows2c.wxGrid_GetCursorColumn(self.this)
+        return val
+    def GetCursorRow(self):
+        val = windows2c.wxGrid_GetCursorRow(self.this)
+        return val
+    def GetEditable(self):
+        val = windows2c.wxGrid_GetEditable(self.this)
+        return val
+    def GetHorizScrollBar(self):
+        val = windows2c.wxGrid_GetHorizScrollBar(self.this)
+        val = wxScrollBarPtr(val)
+        return val
+    def GetLabelAlignment(self,arg0):
+        val = windows2c.wxGrid_GetLabelAlignment(self.this,arg0)
+        return val
+    def GetLabelBackgroundColour(self):
+        val = windows2c.wxGrid_GetLabelBackgroundColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetLabelSize(self,arg0):
+        val = windows2c.wxGrid_GetLabelSize(self.this,arg0)
+        return val
+    def GetLabelTextColour(self):
+        val = windows2c.wxGrid_GetLabelTextColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetLabelTextFont(self):
+        val = windows2c.wxGrid_GetLabelTextFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetLabelValue(self,arg0,arg1):
+        val = windows2c.wxGrid_GetLabelValue(self.this,arg0,arg1)
+        return val
+    def GetRowHeight(self,arg0):
+        val = windows2c.wxGrid_GetRowHeight(self.this,arg0)
+        return val
+    def GetRows(self):
+        val = windows2c.wxGrid_GetRows(self.this)
+        return val
+    def GetScrollPosX(self):
+        val = windows2c.wxGrid_GetScrollPosX(self.this)
+        return val
+    def GetScrollPosY(self):
+        val = windows2c.wxGrid_GetScrollPosY(self.this)
+        return val
+    def GetTextItem(self):
+        val = windows2c.wxGrid_GetTextItem(self.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def GetVertScrollBar(self):
+        val = windows2c.wxGrid_GetVertScrollBar(self.this)
+        val = wxScrollBarPtr(val)
+        return val
+    def InsertCols(self,*args):
+        val = apply(windows2c.wxGrid_InsertCols,(self.this,)+args)
+        return val
+    def InsertRows(self,*args):
+        val = apply(windows2c.wxGrid_InsertRows,(self.this,)+args)
+        return val
+    def OnActivate(self,arg0):
+        val = windows2c.wxGrid_OnActivate(self.this,arg0)
+        return val
+    def SetCellAlignment(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellAlignment(self.this,arg0,arg1,arg2)
+        return val
+    def SetDefCellAlignment(self,arg0):
+        val = windows2c.wxGrid_SetDefCellAlignment(self.this,arg0)
+        return val
+    def SetCellBackgroundColour(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellBackgroundColour(self.this,arg0.this,arg1,arg2)
+        return val
+    def SetDefCellBackgroundColour(self,arg0):
+        val = windows2c.wxGrid_SetDefCellBackgroundColour(self.this,arg0.this)
+        return val
+    def SetCellTextColour(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellTextColour(self.this,arg0.this,arg1,arg2)
+        return val
+    def SetDefCellTextColour(self,arg0):
+        val = windows2c.wxGrid_SetDefCellTextColour(self.this,arg0.this)
+        return val
+    def SetCellTextFont(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellTextFont(self.this,arg0.this,arg1,arg2)
+        return val
+    def SetDefCellTextFont(self,arg0):
+        val = windows2c.wxGrid_SetDefCellTextFont(self.this,arg0.this)
+        return val
+    def SetCellValue(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetCellValue(self.this,arg0,arg1,arg2)
+        return val
+    def SetColumnWidth(self,arg0,arg1):
+        val = windows2c.wxGrid_SetColumnWidth(self.this,arg0,arg1)
+        return val
+    def SetDividerPen(self,arg0):
+        val = windows2c.wxGrid_SetDividerPen(self.this,arg0.this)
+        return val
+    def SetEditable(self,arg0):
+        val = windows2c.wxGrid_SetEditable(self.this,arg0)
+        return val
+    def SetGridCursor(self,arg0,arg1):
+        val = windows2c.wxGrid_SetGridCursor(self.this,arg0,arg1)
+        return val
+    def SetLabelAlignment(self,arg0,arg1):
+        val = windows2c.wxGrid_SetLabelAlignment(self.this,arg0,arg1)
+        return val
+    def SetLabelBackgroundColour(self,arg0):
+        val = windows2c.wxGrid_SetLabelBackgroundColour(self.this,arg0.this)
+        return val
+    def SetLabelSize(self,arg0,arg1):
+        val = windows2c.wxGrid_SetLabelSize(self.this,arg0,arg1)
+        return val
+    def SetLabelTextColour(self,arg0):
+        val = windows2c.wxGrid_SetLabelTextColour(self.this,arg0.this)
+        return val
+    def SetLabelTextFont(self,arg0):
+        val = windows2c.wxGrid_SetLabelTextFont(self.this,arg0.this)
+        return val
+    def SetLabelValue(self,arg0,arg1,arg2):
+        val = windows2c.wxGrid_SetLabelValue(self.this,arg0,arg1,arg2)
+        return val
+    def SetRowHeight(self,arg0,arg1):
+        val = windows2c.wxGrid_SetRowHeight(self.this,arg0,arg1)
+        return val
+    def UpdateDimensions(self):
+        val = windows2c.wxGrid_UpdateDimensions(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxGrid instance>"
+class wxGrid(wxGridPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows2c.new_wxGrid,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._checkForCallback(self, 'OnSelectCell',           wxEVT_GRID_SELECT_CELL)
+        wx._checkForCallback(self, 'OnCreateCell',           wxEVT_GRID_CREATE_CELL)
+        wx._checkForCallback(self, 'OnChangeLabels',         wxEVT_GRID_CHANGE_LABELS)
+        wx._checkForCallback(self, 'OnChangeSelectionLabel', wxEVT_GRID_CHANGE_SEL_LABEL)
+        wx._checkForCallback(self, 'OnCellChange',           wxEVT_GRID_CELL_CHANGE)
+        wx._checkForCallback(self, 'OnCellLeftClick',        wxEVT_GRID_CELL_LCLICK)
+        wx._checkForCallback(self, 'OnCellRightClick',       wxEVT_GRID_CELL_RCLICK)
+        wx._checkForCallback(self, 'OnLabelLeftClick',       wxEVT_GRID_LABEL_LCLICK)
+        wx._checkForCallback(self, 'OnLabelRightClick',      wxEVT_GRID_LABEL_RCLICK)
+
+
+
+
+class wxGridEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __setattr__(self,name,value):
+        if name == "m_row" :
+            windows2c.wxGridEvent_m_row_set(self.this,value)
+            return
+        if name == "m_col" :
+            windows2c.wxGridEvent_m_col_set(self.this,value)
+            return
+        if name == "m_x" :
+            windows2c.wxGridEvent_m_x_set(self.this,value)
+            return
+        if name == "m_y" :
+            windows2c.wxGridEvent_m_y_set(self.this,value)
+            return
+        if name == "m_control" :
+            windows2c.wxGridEvent_m_control_set(self.this,value)
+            return
+        if name == "m_shift" :
+            windows2c.wxGridEvent_m_shift_set(self.this,value)
+            return
+        if name == "m_cell" :
+            windows2c.wxGridEvent_m_cell_set(self.this,value.this)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_row" : 
+            return windows2c.wxGridEvent_m_row_get(self.this)
+        if name == "m_col" : 
+            return windows2c.wxGridEvent_m_col_get(self.this)
+        if name == "m_x" : 
+            return windows2c.wxGridEvent_m_x_get(self.this)
+        if name == "m_y" : 
+            return windows2c.wxGridEvent_m_y_get(self.this)
+        if name == "m_control" : 
+            return windows2c.wxGridEvent_m_control_get(self.this)
+        if name == "m_shift" : 
+            return windows2c.wxGridEvent_m_shift_get(self.this)
+        if name == "m_cell" : 
+            return wxGridCellPtr(windows2c.wxGridEvent_m_cell_get(self.this))
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxGridEvent instance>"
+class wxGridEvent(wxGridEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxNotebookEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSelection(self):
+        val = windows2c.wxNotebookEvent_GetSelection(self.this)
+        return val
+    def GetOldSelection(self):
+        val = windows2c.wxNotebookEvent_GetOldSelection(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxNotebookEvent instance>"
+class wxNotebookEvent(wxNotebookEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxNotebookPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPageCount(self):
+        val = windows2c.wxNotebook_GetPageCount(self.this)
+        return val
+    def SetSelection(self,arg0):
+        val = windows2c.wxNotebook_SetSelection(self.this,arg0)
+        return val
+    def AdvanceSelection(self,*args):
+        val = apply(windows2c.wxNotebook_AdvanceSelection,(self.this,)+args)
+        return val
+    def GetSelection(self):
+        val = windows2c.wxNotebook_GetSelection(self.this)
+        return val
+    def SetPageText(self,arg0,arg1):
+        val = windows2c.wxNotebook_SetPageText(self.this,arg0,arg1)
+        return val
+    def GetPageText(self,arg0):
+        val = windows2c.wxNotebook_GetPageText(self.this,arg0)
+        return val
+    def SetImageList(self,arg0):
+        val = windows2c.wxNotebook_SetImageList(self.this,arg0)
+        return val
+    def GetImageList(self):
+        val = windows2c.wxNotebook_GetImageList(self.this)
+        return val
+    def GetPageImage(self,arg0):
+        val = windows2c.wxNotebook_GetPageImage(self.this,arg0)
+        return val
+    def SetPageImage(self,arg0,arg1):
+        val = windows2c.wxNotebook_SetPageImage(self.this,arg0,arg1)
+        return val
+    def GetRowCount(self):
+        val = windows2c.wxNotebook_GetRowCount(self.this)
+        return val
+    def DeletePage(self,arg0):
+        val = windows2c.wxNotebook_DeletePage(self.this,arg0)
+        return val
+    def DeleteAllPages(self):
+        val = windows2c.wxNotebook_DeleteAllPages(self.this)
+        return val
+    def AddPage(self,arg0,arg1,*args):
+        val = apply(windows2c.wxNotebook_AddPage,(self.this,arg0.this,arg1,)+args)
+        return val
+    def InsertPage(self,arg0,arg1,arg2,*args):
+        val = apply(windows2c.wxNotebook_InsertPage,(self.this,arg0,arg1.this,arg2,)+args)
+        return val
+    def GetPage(self,arg0):
+        val = windows2c.wxNotebook_GetPage(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxNotebook instance>"
+class wxNotebook(wxNotebookPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows2c.new_wxNotebook,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSplitterWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBorderSize(self):
+        val = windows2c.wxSplitterWindow_GetBorderSize(self.this)
+        return val
+    def GetMinimumPaneSize(self):
+        val = windows2c.wxSplitterWindow_GetMinimumPaneSize(self.this)
+        return val
+    def GetSashPosition(self):
+        val = windows2c.wxSplitterWindow_GetSashPosition(self.this)
+        return val
+    def GetSashSize(self):
+        val = windows2c.wxSplitterWindow_GetSashSize(self.this)
+        return val
+    def GetSplitMode(self):
+        val = windows2c.wxSplitterWindow_GetSplitMode(self.this)
+        return val
+    def GetWindow1(self):
+        val = windows2c.wxSplitterWindow_GetWindow1(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def GetWindow2(self):
+        val = windows2c.wxSplitterWindow_GetWindow2(self.this)
+        val = wxWindowPtr(val)
+        return val
+    def Initialize(self,arg0):
+        val = windows2c.wxSplitterWindow_Initialize(self.this,arg0.this)
+        return val
+    def IsSplit(self):
+        val = windows2c.wxSplitterWindow_IsSplit(self.this)
+        return val
+    def SetBorderSize(self,arg0):
+        val = windows2c.wxSplitterWindow_SetBorderSize(self.this,arg0)
+        return val
+    def SetSashPosition(self,arg0,*args):
+        val = apply(windows2c.wxSplitterWindow_SetSashPosition,(self.this,arg0,)+args)
+        return val
+    def SetSashSize(self,arg0):
+        val = windows2c.wxSplitterWindow_SetSashSize(self.this,arg0)
+        return val
+    def SetMinimumPaneSize(self,arg0):
+        val = windows2c.wxSplitterWindow_SetMinimumPaneSize(self.this,arg0)
+        return val
+    def SetSplitMode(self,arg0):
+        val = windows2c.wxSplitterWindow_SetSplitMode(self.this,arg0)
+        return val
+    def SplitHorizontally(self,arg0,arg1,*args):
+        val = apply(windows2c.wxSplitterWindow_SplitHorizontally,(self.this,arg0.this,arg1.this,)+args)
+        return val
+    def SplitVertically(self,arg0,arg1,*args):
+        val = apply(windows2c.wxSplitterWindow_SplitVertically,(self.this,arg0.this,arg1.this,)+args)
+        return val
+    def Unsplit(self,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windows2c.wxSplitterWindow_Unsplit,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxSplitterWindow instance>"
+class wxSplitterWindow(wxSplitterWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows2c.new_wxSplitterWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxTaskBarIconPtr(wxEvtHandlerPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            windows2c.delete_wxTaskBarIcon(self.this)
+    def SetIcon(self,arg0,*args):
+        val = apply(windows2c.wxTaskBarIcon_SetIcon,(self.this,arg0.this,)+args)
+        return val
+    def RemoveIcon(self):
+        val = windows2c.wxTaskBarIcon_RemoveIcon(self.this)
+        return val
+    def PopupMenu(self,arg0):
+        val = windows2c.wxTaskBarIcon_PopupMenu(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxTaskBarIcon instance>"
+class wxTaskBarIcon(wxTaskBarIconPtr):
+    def __init__(self) :
+        self.this = windows2c.new_wxTaskBarIcon()
+        self.thisown = 1
+        wx._checkForCallback(self, 'OnMouseMove',    wxEVT_TASKBAR_MOVE)
+        wx._checkForCallback(self, 'OnLButtonDown',  wxEVT_TASKBAR_LEFT_DOWN)
+        wx._checkForCallback(self, 'OnLButtonUp',    wxEVT_TASKBAR_LEFT_UP)
+        wx._checkForCallback(self, 'OnRButtonDown',  wxEVT_TASKBAR_RIGHT_DOWN)
+        wx._checkForCallback(self, 'OnRButtonUp',    wxEVT_TASKBAR_RIGHT_UP)
+        wx._checkForCallback(self, 'OnLButtonDClick',wxEVT_TASKBAR_LEFT_DCLICK)
+        wx._checkForCallback(self, 'OnRButtonDClick',wxEVT_TASKBAR_RIGHT_DCLICK)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxGRID_TEXT_CTRL = windows2c.wxGRID_TEXT_CTRL
+wxGRID_HSCROLL = windows2c.wxGRID_HSCROLL
+wxGRID_VSCROLL = windows2c.wxGRID_VSCROLL
+wxEVT_GRID_SELECT_CELL = windows2c.wxEVT_GRID_SELECT_CELL
+wxEVT_GRID_CREATE_CELL = windows2c.wxEVT_GRID_CREATE_CELL
+wxEVT_GRID_CHANGE_LABELS = windows2c.wxEVT_GRID_CHANGE_LABELS
+wxEVT_GRID_CHANGE_SEL_LABEL = windows2c.wxEVT_GRID_CHANGE_SEL_LABEL
+wxEVT_GRID_CELL_CHANGE = windows2c.wxEVT_GRID_CELL_CHANGE
+wxEVT_GRID_CELL_LCLICK = windows2c.wxEVT_GRID_CELL_LCLICK
+wxEVT_GRID_CELL_RCLICK = windows2c.wxEVT_GRID_CELL_RCLICK
+wxEVT_GRID_LABEL_LCLICK = windows2c.wxEVT_GRID_LABEL_LCLICK
+wxEVT_GRID_LABEL_RCLICK = windows2c.wxEVT_GRID_LABEL_RCLICK
+wxEVT_TASKBAR_MOVE = windows2c.wxEVT_TASKBAR_MOVE
+wxEVT_TASKBAR_LEFT_DOWN = windows2c.wxEVT_TASKBAR_LEFT_DOWN
+wxEVT_TASKBAR_LEFT_UP = windows2c.wxEVT_TASKBAR_LEFT_UP
+wxEVT_TASKBAR_RIGHT_DOWN = windows2c.wxEVT_TASKBAR_RIGHT_DOWN
+wxEVT_TASKBAR_RIGHT_UP = windows2c.wxEVT_TASKBAR_RIGHT_UP
+wxEVT_TASKBAR_LEFT_DCLICK = windows2c.wxEVT_TASKBAR_LEFT_DCLICK
+wxEVT_TASKBAR_RIGHT_DCLICK = windows2c.wxEVT_TASKBAR_RIGHT_DCLICK

utils/wxPython/src/msw/windows3.py

@@ -0,0 +1,293 @@
+# This file was created automatically by SWIG.
+import windows3c
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+
+from windows2 import *
+
+from controls import *
+
+from events import *
+
+from mdi import *
+
+from frames import *
+
+from stattool import *
+import wx
+class wxSashEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetEdge(self,arg0):
+        val = windows3c.wxSashEvent_SetEdge(self.this,arg0)
+        return val
+    def GetEdge(self):
+        val = windows3c.wxSashEvent_GetEdge(self.this)
+        return val
+    def SetDragRect(self,arg0):
+        val = windows3c.wxSashEvent_SetDragRect(self.this,arg0.this)
+        return val
+    def GetDragRect(self):
+        val = windows3c.wxSashEvent_GetDragRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def SetDragStatus(self,arg0):
+        val = windows3c.wxSashEvent_SetDragStatus(self.this,arg0)
+        return val
+    def GetDragStatus(self):
+        val = windows3c.wxSashEvent_GetDragStatus(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxSashEvent instance>"
+class wxSashEvent(wxSashEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSashWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSashVisible(self,arg0):
+        val = windows3c.wxSashWindow_GetSashVisible(self.this,arg0)
+        return val
+    def GetDefaultBorderSize(self):
+        val = windows3c.wxSashWindow_GetDefaultBorderSize(self.this)
+        return val
+    def GetEdgeMargin(self,arg0):
+        val = windows3c.wxSashWindow_GetEdgeMargin(self.this,arg0)
+        return val
+    def GetExtraBorderSize(self):
+        val = windows3c.wxSashWindow_GetExtraBorderSize(self.this)
+        return val
+    def GetMaximumSizeX(self):
+        val = windows3c.wxSashWindow_GetMaximumSizeX(self.this)
+        return val
+    def GetMaximumSizeY(self):
+        val = windows3c.wxSashWindow_GetMaximumSizeY(self.this)
+        return val
+    def GetMinimumSizeX(self):
+        val = windows3c.wxSashWindow_GetMinimumSizeX(self.this)
+        return val
+    def GetMinimumSizeY(self):
+        val = windows3c.wxSashWindow_GetMinimumSizeY(self.this)
+        return val
+    def HasBorder(self,arg0):
+        val = windows3c.wxSashWindow_HasBorder(self.this,arg0)
+        return val
+    def SetDefaultBorderSize(self,arg0):
+        val = windows3c.wxSashWindow_SetDefaultBorderSize(self.this,arg0)
+        return val
+    def SetExtraBorderSize(self,arg0):
+        val = windows3c.wxSashWindow_SetExtraBorderSize(self.this,arg0)
+        return val
+    def SetMaximumSizeX(self,arg0):
+        val = windows3c.wxSashWindow_SetMaximumSizeX(self.this,arg0)
+        return val
+    def SetMaximumSizeY(self,arg0):
+        val = windows3c.wxSashWindow_SetMaximumSizeY(self.this,arg0)
+        return val
+    def SetMinimumSizeX(self,arg0):
+        val = windows3c.wxSashWindow_SetMinimumSizeX(self.this,arg0)
+        return val
+    def SetMinimumSizeY(self,arg0):
+        val = windows3c.wxSashWindow_SetMinimumSizeY(self.this,arg0)
+        return val
+    def SetSashVisible(self,arg0,arg1):
+        val = windows3c.wxSashWindow_SetSashVisible(self.this,arg0,arg1)
+        return val
+    def SetSashBorder(self,arg0,arg1):
+        val = windows3c.wxSashWindow_SetSashBorder(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxSashWindow instance>"
+class wxSashWindow(wxSashWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows3c.new_wxSashWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxQueryLayoutInfoEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetRequestedLength(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetRequestedLength(self.this,arg0)
+        return val
+    def GetRequestedLength(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetRequestedLength(self.this)
+        return val
+    def SetFlags(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetFlags(self.this,arg0)
+        return val
+    def GetFlags(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetFlags(self.this)
+        return val
+    def SetSize(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetSize(self.this,arg0.this)
+        return val
+    def GetSize(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def SetOrientation(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetOrientation(self.this,arg0)
+        return val
+    def GetOrientation(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetOrientation(self.this)
+        return val
+    def SetAlignment(self,arg0):
+        val = windows3c.wxQueryLayoutInfoEvent_SetAlignment(self.this,arg0)
+        return val
+    def GetAlignment(self):
+        val = windows3c.wxQueryLayoutInfoEvent_GetAlignment(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxQueryLayoutInfoEvent instance>"
+class wxQueryLayoutInfoEvent(wxQueryLayoutInfoEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCalculateLayoutEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetFlags(self,arg0):
+        val = windows3c.wxCalculateLayoutEvent_SetFlags(self.this,arg0)
+        return val
+    def GetFlags(self):
+        val = windows3c.wxCalculateLayoutEvent_GetFlags(self.this)
+        return val
+    def SetRect(self,arg0):
+        val = windows3c.wxCalculateLayoutEvent_SetRect(self.this,arg0.this)
+        return val
+    def GetRect(self):
+        val = windows3c.wxCalculateLayoutEvent_GetRect(self.this)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxCalculateLayoutEvent instance>"
+class wxCalculateLayoutEvent(wxCalculateLayoutEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSashLayoutWindowPtr(wxSashWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetAlignment(self):
+        val = windows3c.wxSashLayoutWindow_GetAlignment(self.this)
+        return val
+    def GetOrientation(self):
+        val = windows3c.wxSashLayoutWindow_GetOrientation(self.this)
+        return val
+    def SetAlignment(self,arg0):
+        val = windows3c.wxSashLayoutWindow_SetAlignment(self.this,arg0)
+        return val
+    def SetDefaultSize(self,arg0):
+        val = windows3c.wxSashLayoutWindow_SetDefaultSize(self.this,arg0.this)
+        return val
+    def SetOrientation(self,arg0):
+        val = windows3c.wxSashLayoutWindow_SetOrientation(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSashLayoutWindow instance>"
+class wxSashLayoutWindow(wxSashLayoutWindowPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(windows3c.new_wxSashLayoutWindow,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+        wx._checkForCallback(self, 'OnCalculateLayout',    wxEVT_CALCULATE_LAYOUT)
+        wx._checkForCallback(self, 'OnQueryLayoutInfo',    wxEVT_QUERY_LAYOUT_INFO)
+
+
+
+
+class wxLayoutAlgorithmPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            windows3c.delete_wxLayoutAlgorithm(self.this)
+    def LayoutMDIFrame(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windows3c.wxLayoutAlgorithm_LayoutMDIFrame,(self.this,arg0.this,)+args)
+        return val
+    def LayoutFrame(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(windows3c.wxLayoutAlgorithm_LayoutFrame,(self.this,arg0.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxLayoutAlgorithm instance>"
+class wxLayoutAlgorithm(wxLayoutAlgorithmPtr):
+    def __init__(self) :
+        self.this = windows3c.new_wxLayoutAlgorithm()
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxSASH_TOP = windows3c.wxSASH_TOP
+wxSASH_RIGHT = windows3c.wxSASH_RIGHT
+wxSASH_BOTTOM = windows3c.wxSASH_BOTTOM
+wxSASH_LEFT = windows3c.wxSASH_LEFT
+wxSASH_NONE = windows3c.wxSASH_NONE
+wxEVT_SASH_DRAGGED = windows3c.wxEVT_SASH_DRAGGED
+wxSW_3D = windows3c.wxSW_3D
+wxSASH_STATUS_OK = windows3c.wxSASH_STATUS_OK
+wxSASH_STATUS_OUT_OF_RANGE = windows3c.wxSASH_STATUS_OUT_OF_RANGE
+wxLAYOUT_HORIZONTAL = windows3c.wxLAYOUT_HORIZONTAL
+wxLAYOUT_VERTICAL = windows3c.wxLAYOUT_VERTICAL
+wxLAYOUT_NONE = windows3c.wxLAYOUT_NONE
+wxLAYOUT_TOP = windows3c.wxLAYOUT_TOP
+wxLAYOUT_LEFT = windows3c.wxLAYOUT_LEFT
+wxLAYOUT_RIGHT = windows3c.wxLAYOUT_RIGHT
+wxLAYOUT_BOTTOM = windows3c.wxLAYOUT_BOTTOM
+wxEVT_QUERY_LAYOUT_INFO = windows3c.wxEVT_QUERY_LAYOUT_INFO
+wxEVT_CALCULATE_LAYOUT = windows3c.wxEVT_CALCULATE_LAYOUT

utils/wxPython/src/my_typemaps.i

@@ -0,0 +1,216 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        my_typemaps.i
+// Purpose:     Special typemaps specifically for wxPython.
+//
+// Author:      Robin Dunn
+//
+// Created:     7/3/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+//----------------------------------------------------------------------
+// Here are some to map (int LCOUNT, int* LIST), etc. from a python list
+
+%{
+
+extern byte* byte_LIST_helper(PyObject* source);
+extern int* int_LIST_helper(PyObject* source);
+extern long* long_LIST_helper(PyObject* source);
+extern char** string_LIST_helper(PyObject* source);
+extern wxPoint* wxPoint_LIST_helper(PyObject* source);
+extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
+extern wxString* wxString_LIST_helper(PyObject* source);
+extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+
+%}
+
+//----------------------------------------------------------------------
+
+%typemap(python,build) int LCOUNT {
+    $target = PyList_Size(_in_LIST);
+}
+
+
+
+%typemap(python,in) byte* LIST  {
+    $target = byte_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) byte* LIST {
+    delete [] $source;
+}
+
+
+%typemap(python,in) int* LIST  {
+    $target = int_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) int* LIST {
+    delete [] $source;
+}
+
+
+%typemap(python,in) long* LIST {
+    $target = long_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) long* LIST {
+    delete [] $source;
+}
+
+
+%typemap(python,in) unsigned long* LIST {
+    $target = (unsigned long*)long_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) unsigned long* LIST {
+    delete [] $source;
+}
+
+
+
+%typemap(python,in) wxDash* LIST = unsigned long* LIST;
+%typemap(python,freearg) wxDash* LIST = unsigned long* LIST;
+
+
+%typemap(python,in) char** LIST {
+    $target = string_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) char** LIST {
+    delete [] $source;
+}
+
+
+
+%typemap(python,in) wxPoint* LIST  {
+    $target = wxPoint_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) wxPoint* LIST {
+    delete [] $source;
+}
+
+%typemap(python,in) wxBitmap** LIST  {
+    $target = wxBitmap_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) wxBitmap** LIST {
+    delete [] $source;
+}
+
+%typemap(python,in) wxString* LIST  {
+    $target = wxString_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) wxString* LIST {
+    delete [] $source;
+}
+
+%typemap(python,in) wxAcceleratorEntry* LIST  {
+    $target = wxAcceleratorEntry_LIST_helper($source);
+    if ($target == NULL) {
+        return NULL;
+    }
+}
+%typemap(python,freearg) wxAcceleratorEntry* LIST {
+    delete [] $source;
+}
+
+
+//---------------------------------------------------------------------------
+
+%{
+static char* wxStringErrorMsg = "string type is required for parameter";
+%}
+
+%typemap(python, in) wxString& {
+    if (!PyString_Check($source)) {
+        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+        return NULL;
+    }
+    $target = new wxString(PyString_AsString($source));
+}
+%typemap(python, freearg) wxString& {
+    if ($target)
+        delete $source;
+}
+
+
+
+%typemap(python, out) wxString {
+    $target = PyString_FromString(WXSTRINGCAST *($source));
+}
+%typemap(python, ret) wxString {
+    delete $source;
+}
+
+
+%typemap(python, out) wxString* {
+    $target = PyString_FromString(WXSTRINGCAST (*$source));
+}
+
+
+// --------------------------------------------------------------------
+//---------------------------------------------------------------------------
+
+
+
+// --------------------------------------------------------------------
+// Map T_OUTPUTs for floats to return ints.
+
+
+%typemap(python,ignore) float          *T_OUTPUT_TOINT(float temp),
+                        double         *T_OUTPUT_TOINT(double temp)
+{
+  $target = &temp;
+}
+
+
+%typemap(python,argout) float          *T_OUTPUT_TOINT,
+                        double         *T_OUTPUT_TOINT
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*$source));
+    $target = t_output_helper($target, o);
+}
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.4  1998/11/25 08:45:27  RD
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.3  1998/11/15 23:03:47  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.2  1998/08/14 23:36:39  RD
+// Beginings of wxGTK compatibility
+//
+// Revision 1.1  1998/08/09 08:25:52  RD
+// Initial version
+//
+//
+

utils/wxPython/src/stattool.i

@@ -0,0 +1,257 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        stattool.i
+// Purpose:     SWIG definitions for StatusBar and ToolBar classes
+//
+// Author:      Robin Dunn
+//
+// Created:     08/24/1998
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module stattool
+
+%{
+#include "helpers.h"
+#include <wx/toolbar.h>
+#include <wx/tbarsmpl.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import windows.i
+%import controls.i
+
+%pragma(python) code = "import wx"
+
+//---------------------------------------------------------------------------
+
+class wxStatusBar : public wxWindow {
+public:
+    wxStatusBar(wxWindow* parent, wxWindowID id,
+                const wxPoint& pos = wxPyDefaultPosition,
+                const wxSize& size = wxPyDefaultSize,
+                long style = wxST_SIZEGRIP,
+                char* name = "statusBar");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    %addmethods {
+        %new wxRect* GetFieldRect(long item) {
+            wxRect* rect= new wxRect;
+            self->GetFieldRect(item, *rect);
+            return rect;
+        }
+    }
+    int GetFieldsCount(void);
+    wxString GetStatusText(int ir = 0);
+    void DrawField(wxDC& dc, int i);
+    void DrawFieldText(wxDC& dc, int i);
+    void InitColours(void);
+
+    // OnSysColourChanged(wxSysColourChangedEvent& event);
+
+    void SetFieldsCount(int number = 1);
+    void SetStatusText(const wxString& text, int i = 0);
+    void SetStatusWidths(int LCOUNT, int* LIST);
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxToolBarTool {
+public:
+    wxToolBarTool();
+    ~wxToolBarTool();
+#ifdef __WXMSW__
+    void SetSize( long w, long h ) { m_width = w; m_height = h; }
+    long GetWidth () const { return m_width; }
+    long GetHeight () const { return m_height; }
+#endif
+
+public:
+    int                   m_toolStyle;
+    wxObject *            m_clientData;
+    int                   m_index;
+#ifdef __WXMSW__
+    long                  m_x;
+    long                  m_y;
+    long                  m_width;
+    long                  m_height;
+#endif
+    bool                  m_toggleState;
+    bool                  m_isToggle;
+    bool                  m_deleteSecondBitmap;
+    bool                  m_enabled;
+    wxBitmap              m_bitmap1;
+    wxBitmap              m_bitmap2;
+    bool                  m_isMenuCommand;
+    wxString              m_shortHelpString;
+    wxString              m_longHelpString;
+};
+
+
+
+//  class wxToolBarBase : public wxControl {
+//  public:
+
+class wxToolBar : public wxControl {
+public:
+    wxToolBar(wxWindow* parent, wxWindowID id,
+              const wxPoint& pos = wxPyDefaultPosition,
+              const wxSize& size = wxPyDefaultSize,
+              long style = wxTB_HORIZONTAL | wxNO_BORDER,
+              char* name = "toolBar");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+
+    void AddSeparator();
+
+    // Ignoge the clientData for now...
+    %addmethods {
+        wxToolBarTool* AddTool(int toolIndex,
+                               const wxBitmap& bitmap1,
+                               const wxBitmap& bitmap2 = wxNullBitmap,
+                               int  isToggle = FALSE,
+                               long xPos = -1,
+                               long yPos = -1,
+                               //wxObject* clientData = NULL,
+                               const wxString& shortHelpString = wxPyEmptyStr,
+                               const wxString& longHelpString = wxPyEmptyStr) {
+            return self->AddTool(toolIndex, bitmap1, bitmap2,
+                                 isToggle, xPos, yPos, NULL,
+                                 shortHelpString, longHelpString);
+        }
+
+        wxToolBarTool* AddSimpleTool(int toolIndex,
+                               const wxBitmap& bitmap,
+                               const wxString& shortHelpString = wxPyEmptyStr,
+                               const wxString& longHelpString = wxPyEmptyStr) {
+            return self->AddTool(toolIndex, bitmap, wxNullBitmap,
+                                 FALSE, -1, -1, NULL,
+                                 shortHelpString, longHelpString);
+        }
+    }
+
+
+//    void DrawTool(wxMemoryDC& memDC, wxToolBarTool* tool);
+    void EnableTool(int toolIndex, const bool enable);
+#ifdef __WXMSW__
+    wxToolBarTool* FindToolForPosition(const float x, const float y);
+    wxSize GetToolSize();
+    wxSize GetToolBitmapSize();
+    void SetToolBitmapSize(const wxSize& size);
+//    wxSize GetMargins();
+    wxSize GetMaxSize();
+//    wxObject* GetToolClientData(int toolIndex);
+#endif
+    bool GetToolEnabled(int toolIndex);
+    wxString GetToolLongHelp(int toolIndex);
+    int GetToolPacking();
+    int GetToolSeparation();
+    wxString GetToolShortHelp(int toolIndex);
+    bool GetToolState(int toolIndex);
+
+    // TODO:  figure out how to handle these
+    //bool OnLeftClick(int toolIndex, bool toggleDown);
+    //void OnMouseEnter(int toolIndex);
+    //void OnRightClick(int toolIndex, float x, float y);
+
+    bool Realize();
+
+    void SetToolLongHelp(int toolIndex, const wxString& helpString);
+    void SetToolShortHelp(int toolIndex, const wxString& helpString);
+    void SetMargins(const wxSize& size);
+    void SetToolPacking(int packing);
+    void SetToolSeparation(int separation);
+    void ToggleTool(int toolIndex, const bool toggle);
+};
+
+
+
+//  // The Native Toolbar
+//  class wxToolBar : public wxToolBarBase {
+//  public:
+//      wxToolBar(wxWindow* parent, wxWindowID id,
+//                const wxPoint& pos = wxPyDefaultPosition,
+//                const wxSize& size = wxPyDefaultSize,
+//                long style = wxTB_HORIZONTAL | wxNO_BORDER,
+//                char* name = "toolBar");
+
+//      %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+//  };
+
+
+//  // A generic toolbar
+//  class wxToolBarSimple : public wxToolBarBase {
+//  public:
+//      wxToolBarSimple(wxWindow* parent, wxWindowID id,
+//                      const wxPoint& pos = wxPyDefaultPosition,
+//                      const wxSize& size = wxPyDefaultSize,
+//                      long style = wxTB_HORIZONTAL | wxNO_BORDER,
+//                      char* name = "toolBar");
+
+//      %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+//  };
+
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.5  1999/01/30 07:30:15  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.4  1998/12/17 14:07:43  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.3  1998/12/15 20:41:23  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.2  1998/10/07 07:34:34  RD
+// Version 0.4.1 for wxGTK
+//
+// Revision 1.1  1998/10/02 06:40:42  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+//
+
+
+
+
+
+
+

utils/wxPython/src/utils.i

@@ -0,0 +1,159 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        utils.i
+// Purpose:     SWIG definitions of various utility classes classes
+//
+// Author:      Robin Dunn
+//
+// Created:     25-nov-1998
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module utils
+
+%{
+#include "helpers.h"
+#include <wx/config.h>
+%}
+
+//---------------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+
+#ifdef SEPARATE
+%{
+    static wxString wxPyEmptyStr("");
+%}
+#endif
+
+
+%{
+    static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
+        PyObject* ret = PyTuple_New(3);
+        if (ret) {
+            PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
+            PyTuple_SET_ITEM(ret, 1, PyString_FromString(str));
+            PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
+        }
+        return ret;
+    }
+%}
+
+//---------------------------------------------------------------------------
+
+class wxConfig {
+public:
+    wxConfig(const wxString& appName = wxPyEmptyStr,
+             const wxString& vendorName = wxPyEmptyStr,
+             const wxString& localFilename = wxPyEmptyStr,
+             const wxString& globalFilename = wxPyEmptyStr,
+             long style = 0);
+    ~wxConfig();
+
+    //static wxConfigBase * Create();
+    //static wxConfigBase * Get();
+    //static wxConfigBase * Set(wxConfigBase *pConfig);
+
+
+
+    void DontCreateOnDemand();
+    // **** DANGER Will Robinson! DANGER!  bool DeleteAll();
+    bool DeleteEntry(const wxString& key, bool bDeleteGroupIfEmpty = TRUE);
+    bool DeleteGroup(const wxString& key);
+    bool Exists(wxString& strName);
+    bool Flush(bool bCurrentOnly = FALSE);
+    wxString GetAppName();
+
+
+    // Each of these enumeration methods return a 3-tuple consisting of
+    // the continue flag, the value string, and the index for the next call.
+    %addmethods {
+        PyObject* GetFirstGroup() {
+            bool     cont;
+            long     index = 0;
+            wxString value;
+
+            cont = self->GetFirstGroup(value, index);
+            return __EnumerationHelper(cont, value, index);
+        }
+
+        PyObject* GetFirstEntry() {
+            bool     cont;
+            long     index = 0;
+            wxString value;
+
+            cont = self->GetFirstEntry(value, index);
+            return __EnumerationHelper(cont, value, index);
+        }
+
+        PyObject* GetNextGroup(long index) {
+            bool     cont;
+            wxString value;
+
+            cont = self->GetNextGroup(value, index);
+            return __EnumerationHelper(cont, value, index);
+        }
+
+        PyObject* GetNextEntry(long index) {
+            bool     cont;
+            wxString value;
+
+            cont = self->GetNextEntry(value, index);
+            return __EnumerationHelper(cont, value, index);
+        }
+    }
+
+
+    int GetNumberOfEntries(bool bRecursive = FALSE);
+    int GetNumberOfGroups(bool bRecursive = FALSE);
+    wxString GetPath();
+    wxString GetVendorName();
+    bool HasEntry(wxString& strName);
+    bool HasGroup(const wxString& strName);
+    bool IsExpandingEnvVars();
+    bool IsRecordingDefaults();
+
+    wxString Read(const wxString& key, const wxString& defaultVal = wxPyEmptyStr);
+    %name(ReadInt)long Read(const wxString& key, long defaultVal = 0);
+    %name(ReadFloat)double Read(const wxString& key, double defaultVal = 0.0);
+
+    void SetAppName(const wxString& appName);
+    void SetExpandEnvVars (bool bDoIt = TRUE);
+    void SetPath(const wxString& strPath);
+    void SetRecordDefaults(bool bDoIt = TRUE);
+    void SetVendorName(const wxString& vendorName);
+
+    bool Write(const wxString& key, const wxString& value);
+    %name(WriteInt)bool Write(const wxString& key, long value);
+    %name(WriteFloat)bool Write(const wxString& key, double value);
+
+};
+
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.1  1998/12/15 20:41:23  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//

utils/wxPython/src/utilsc.def

@@ -0,0 +1,2 @@
+EXPORTS
+  initutilsc

utils/wxPython/src/windows.i

@@ -0,0 +1,417 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        windows.i
+// Purpose:     SWIG definitions of various window classes
+//
+// Author:      Robin Dunn
+//
+// Created:     6/24/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module windows
+
+%{
+#include "helpers.h"
+#include <wx/menuitem.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import gdi.i
+
+%pragma(python) code = "import wx"
+
+//---------------------------------------------------------------------------
+
+class wxEvtHandler {
+public:
+    %addmethods {
+        void Connect( int id, int lastId, int eventType, PyObject* func) {
+            if (PyCallable_Check(func)) {
+                self->Connect(id, lastId, eventType,
+                          (wxObjectEventFunction) &wxPyCallback::EventThunker,
+                          new wxPyCallback(func));
+            }
+        }
+    }
+};
+
+
+//----------------------------------------------------------------------
+
+
+class wxWindow : public wxEvtHandler {
+public:
+
+    wxWindow(wxWindow* parent, const wxWindowID id,
+             const wxPoint& pos = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             long style = 0,
+             char* name = "panel");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void CaptureMouse();
+    void Center(int direction = wxHORIZONTAL);
+    void Centre(int direction = wxHORIZONTAL);
+    void ClientToScreen(int *BOTH, int *BOTH);
+    bool Close(int force = FALSE);
+    bool Destroy();
+    void DestroyChildren();
+#ifdef __WXMSW__
+    void DragAcceptFiles(bool accept);
+#endif
+    void Enable(bool enable);
+    //bool FakePopupMenu(wxMenu* menu, int x, int y);
+    %name(FindWindowByID) wxWindow* FindWindow(long id);
+    %name(FindWindowByName) wxWindow* FindWindow(const wxString& name);
+    void Fit();
+    wxColour GetBackgroundColour();
+    int  GetCharHeight();
+    int  GetCharWidth();
+    %name(GetClientSizeTuple) void GetClientSize(int *OUTPUT, int *OUTPUT);
+    wxSize GetClientSize();
+    wxLayoutConstraints * GetConstraints();
+#ifdef __WXMSW__
+    wxButton* GetDefaultItem();
+#endif
+    //wxEvtHandler* GetEventHandler();
+
+    wxFont& GetFont();
+    wxColour GetForegroundColour();
+    wxWindow * GetGrandParent();
+    int GetId();
+    wxString GetLabel();
+    wxString GetName();
+    wxWindow * GetParent();
+    %name(GetPositionTuple) void GetPosition(int *OUTPUT, int *OUTPUT);
+    wxPoint GetPosition();
+    wxRect GetRect();
+    int  GetReturnCode();
+    int GetScrollThumb(int orientation);
+    int GetScrollPos(int orientation);
+    int GetScrollRange(int orientation);
+    %name(GetSizeTuple) void GetSize(int *OUTPUT, int *OUTPUT);
+    wxSize GetSize();
+    void GetTextExtent(const wxString& string, int *OUTPUT, int *OUTPUT); // int* descent = NULL, int* externalLeading = NULL, const wxFont* font = NULL, bool use16 = FALSE)
+    wxString GetTitle();
+    long GetWindowStyleFlag();
+    void InitDialog();
+    bool IsEnabled();
+    bool IsRetained();
+    bool IsShown();
+    void Layout();
+    bool LoadFromResource(wxWindow* parent, const wxString& resourceName, const wxResourceTable* resourceTable = NULL);
+    void Lower();
+    void MakeModal(bool flag);
+    void Move(int x, int y);
+
+    //wxEvtHandler* PopEventHandler(bool deleteHandler = FALSE);
+    bool PopupMenu(wxMenu *menu, int x, int y);
+    //void PushEventHandler(wxEvtHandler* handler);
+
+    void Raise();
+    void Refresh(bool eraseBackground = TRUE, const wxRect* rect = NULL);
+    void ReleaseMouse();
+    void ScreenToClient(int *BOTH, int *BOTH);
+    void ScrollWindow(int dx, int dy, const wxRect* rect = NULL);
+    void SetAcceleratorTable(const wxAcceleratorTable& accel);
+    void SetAutoLayout(bool autoLayout);
+    void SetBackgroundColour(const wxColour& colour);
+    void SetConstraints(wxLayoutConstraints *constraints);
+    void SetDoubleClick(bool allowDoubleClick);
+    void SetFocus();
+    void SetFont(const wxFont& font);
+    void SetForegroundColour(const wxColour& colour);
+    void SetId(int id);
+    void SetName(const wxString& name);
+    void SetReturnCode(int retCode);
+    void SetScrollbar(int orientation, int position, int thumbSize, int range, bool refresh = TRUE);
+    void SetScrollPos(int orientation, int pos, bool refresh = TRUE);
+
+    //void SetSize(int x, int y, int width, int height, int sizeFlags=wxSIZE_AUTO);
+    //%name(SetSizeOnly) void SetSize(int width, int height);
+
+    %name(SetDimensions) void SetSize(int x, int y, int width, int height, int sizeFlags=wxSIZE_AUTO);
+    %addmethods {
+        void SetSize(const wxSize& size) {
+            self->SetSize(size.x, size.y);
+        }
+
+        void SetPosition(const wxPoint& pos) {
+            self->SetSize(pos.x, pos.y, -1, -1);
+        }
+    }
+
+    void SetSizeHints(int minW=-1, int minH=-1, int maxW=-1, int maxH=-1, int incW=-1, int incH=-1);
+    void SetClientSize(int width, int height);
+    //void SetPalette(wxPalette* palette);
+    void SetCursor(const wxCursor&cursor);
+    //void SetEventHandler(wxEvtHandler* handler);
+    void SetTitle(const wxString& title);
+    bool Show(bool show);
+    bool TransferDataFromWindow();
+    bool TransferDataToWindow();
+    bool Validate();
+    void WarpPointer(int x, int y);
+
+    %name(ConvertDialogPointToPixels) wxPoint ConvertDialogToPixels(const wxPoint& pt);
+    %name(ConvertDialogSizeToPixels)  wxSize  ConvertDialogToPixels(const wxSize& sz);
+
+    %name(ConvertPixelPointToDialog) wxPoint ConvertPixelsToDialog(const wxPoint& pt);
+    %name(ConvertPixelSizeToDialog)  wxSize  ConvertPixelsToDialog(const wxSize& sz);
+
+};
+
+%pragma(python) code = "
+def wxDLG_PNT(win, point):
+    return win.ConvertDialogPointToPixels(point)
+
+def wxDLG_SZE(win, size):
+    return win.ConvertDialogPointToPixels(size)
+"
+
+// Static method(s)
+#ifdef __WXMSW__
+%inline %{
+    wxWindow* wxWindow_FindFocus() {
+        return wxWindow::FindFocus();
+    }
+%}
+#endif
+
+
+//---------------------------------------------------------------------------
+
+class wxPanel : public wxWindow {
+public:
+    wxPanel(wxWindow* parent,
+            const wxWindowID id,
+            const wxPoint& pos = wxPyDefaultPosition,
+            const wxSize& size = wxPyDefaultSize,
+            long style = wxTAB_TRAVERSAL,
+            const char* name = "panel");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void InitDialog();
+};
+
+//---------------------------------------------------------------------------
+
+class wxDialog : public wxPanel {
+public:
+    wxDialog(wxWindow* parent,
+             const wxWindowID id,
+             const wxString& title,
+             const wxPoint& pos = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             long style = wxDEFAULT_DIALOG_STYLE,
+             const char* name = "dialogBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    void Centre(int direction = wxBOTH);
+    void EndModal(int retCode);
+    wxString GetTitle();
+    void Iconize(bool iconize);
+    bool IsIconized();
+    void SetModal(bool flag);
+    bool IsModal();
+    void SetTitle(const wxString& title);
+    bool Show(bool show);
+    int ShowModal();
+};
+
+//---------------------------------------------------------------------------
+
+class wxScrolledWindow : public wxWindow {
+public:
+    wxScrolledWindow(wxWindow* parent,
+                     const wxWindowID id = -1,
+                     const wxPoint& pos = wxPyDefaultPosition,
+                     const wxSize& size = wxPyDefaultSize,
+                     long style = wxHSCROLL | wxVSCROLL,
+                     char* name = "scrolledWindow");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+    %pragma(python) addtomethod = "__init__:wx._StdOnScrollCallbacks(self)"
+
+    void EnableScrolling(bool xScrolling, bool yScrolling);
+    void GetScrollPixelsPerUnit(int* OUTPUT, int* OUTPUT);
+    void GetVirtualSize(int* OUTPUT, int* OUTPUT);
+    bool IsRetained();
+    void PrepareDC(wxDC& dc);
+    void Scroll(int x, int y);
+    void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
+                       int noUnitsX, int noUnitsY,
+                       int xPos = 0, int yPos = 0);
+    void ViewStart(int* OUTPUT, int* OUTPUT);
+};
+
+//----------------------------------------------------------------------
+
+
+class wxMenu : public wxEvtHandler {
+public:
+    wxMenu(const wxString& title = wxPyEmptyStr);
+
+    void Append(int id, const wxString& item,
+                const wxString& helpString = wxPyEmptyStr,
+                int checkable = FALSE);
+    %name(AppendMenu)void Append(int id, const wxString& item, wxMenu *subMenu,
+                const wxString& helpString = wxPyEmptyStr);
+    void AppendSeparator();
+    void Break();
+    void Check(int id, bool flag);
+    void Enable(int id, bool enable);
+    int FindItem(const wxString& itemString);
+    wxString GetTitle();
+    void SetTitle(const wxString& title);
+    wxMenuItem* FindItemForId(int id);
+    wxString GetHelpString(int id);
+    wxString GetLabel(int id);
+    void SetHelpString(int id, const wxString& helpString);
+    bool IsChecked(int id);
+    bool IsEnabled(int id);
+    void SetLabel(int id, const wxString& label);
+};
+
+
+//
+// This one knows how to set a callback and handle INC- and DECREFing it.  To
+// be used for PopupMenus, but you must retain a referece to it while using
+// it.
+//
+class wxPyMenu : public wxMenu {
+public:
+    wxPyMenu(const wxString& title = wxPyEmptyStr, PyObject* func = NULL);
+    ~wxPyMenu();
+};
+
+//----------------------------------------------------------------------
+
+class wxMenuBar : public wxEvtHandler {
+public:
+    wxMenuBar();
+
+    void Append(wxMenu *menu, const wxString& title);
+    void Check(int id, bool flag);
+    bool Checked(int id);
+    void Enable(int id, bool enable);
+    bool Enabled(int id);
+    int FindMenuItem(const wxString& menuString, const wxString& itemString);
+    wxMenuItem * FindItemForId(int id);
+#ifdef __WXMSW__
+    void EnableTop(int pos, bool enable);
+    wxString GetHelpString(int id);
+    wxString GetLabel(int id);
+    void SetHelpString(int id, const wxString& helpString);
+    void SetLabel(int id, const wxString& label);
+    wxString GetLabelTop(int pos);
+    void SetLabelTop(int pos, const wxString& label);
+#endif
+    int GetMenuCount();
+    wxMenu* GetMenu(int i);
+};
+
+
+//----------------------------------------------------------------------
+
+class wxMenuItem {
+public:
+    bool IsSeparator();
+    bool IsEnabled();
+    bool IsChecked();
+    bool IsCheckable();
+    int  GetId();
+    wxMenu* GetSubMenu();
+    void SetName(const wxString& strName);
+    const wxString& GetName();
+    const wxString& GetHelp();
+    void SetHelp(const wxString& strHelp);
+    void Enable(bool bDoEnable = TRUE);
+    void Check(bool bDoCheck = TRUE);
+
+#ifdef __WXMSW__
+    void DeleteSubMenu();
+#endif
+};
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.11  1998/12/18 15:49:10  RR
+//   wxClipboard now serves the primary selection as well
+//   wxPython fixes
+//   warning mesages
+//
+// Revision 1.10  1998/12/17 17:52:20  RD
+//
+// wxPython 0.5.2
+// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
+// versions are much closer now!
+//
+// Revision 1.9  1998/12/17 14:07:46  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.8  1998/12/16 22:10:56  RD
+//
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.7  1998/12/15 20:41:25  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.6  1998/10/02 06:40:43  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.5  1998/08/17 18:29:40  RD
+// Removed an extra method definition
+//
+// Revision 1.4  1998/08/16 04:31:11  RD
+// More wxGTK work.
+//
+// Revision 1.3  1998/08/15 07:36:47  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.2  1998/08/14 23:36:46  RD
+// Beginings of wxGTK compatibility
+//
+// Revision 1.1  1998/08/09 08:25:52  RD
+// Initial version
+//
+//
+
+

utils/wxPython/src/windows2.i

@@ -0,0 +1,388 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        windows2.i
+// Purpose:     SWIG definitions of MORE window classes
+//
+// Author:      Robin Dunn
+//
+// Created:     6/2/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module windows2
+
+%{
+#include "helpers.h"
+#include <wx/grid.h>
+#include <wx/notebook.h>
+#include <wx/splitter.h>
+#ifdef __WXMSW__
+#include <wx/msw/taskbar.h>
+#endif
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import gdi.i
+%import windows.i
+%import controls.i
+%import events.i
+
+%pragma(python) code = "import wx"
+
+//---------------------------------------------------------------------------
+
+
+enum {
+    wxGRID_TEXT_CTRL,
+    wxGRID_HSCROLL,
+    wxGRID_VSCROLL
+};
+
+class wxGridCell {
+public:
+    wxGridCell();
+    ~wxGridCell();
+
+    wxString& GetTextValue();
+    void      SetTextValue(const wxString& str);
+    wxFont&   GetFont();
+    void      SetFont(wxFont& f);
+    wxColour& GetTextColour();
+    void      SetTextColour(const wxColour& colour);
+    wxColour& GetBackgroundColour();
+    void      SetBackgroundColour(const wxColour& colour);
+    wxBrush&  GetBackgroundBrush();
+    int       GetAlignment();
+    void      SetAlignment(int align);
+    wxBitmap* GetCellBitmap();
+    void      SetCellBitmap(wxBitmap* bitmap);
+};
+
+
+
+
+class wxGrid : public wxPanel {
+public:
+    wxGrid(wxWindow* parent, wxWindowID id,
+           const wxPoint& pos=wxPyDefaultPosition,
+           const wxSize& size=wxPyDefaultSize,
+           long style=0,
+           char* name="grid");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnSelectCell',           wxEVT_GRID_SELECT_CELL)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnCreateCell',           wxEVT_GRID_CREATE_CELL)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnChangeLabels',         wxEVT_GRID_CHANGE_LABELS)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnChangeSelectionLabel', wxEVT_GRID_CHANGE_SEL_LABEL)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnCellChange',           wxEVT_GRID_CELL_CHANGE)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnCellLeftClick',        wxEVT_GRID_CELL_LCLICK)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnCellRightClick',       wxEVT_GRID_CELL_RCLICK)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLabelLeftClick',       wxEVT_GRID_LABEL_LCLICK)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLabelRightClick',      wxEVT_GRID_LABEL_RCLICK)"
+
+
+    void AdjustScrollbars();
+    bool AppendCols(int n=1, bool updateLabels=TRUE);
+    bool AppendRows(int n=1, bool updateLabels=TRUE);
+    void BeginBatch();
+    bool CellHitTest(int x, int y, int *OUTPUT, int *OUTPUT);
+
+    %addmethods {
+        // TODO:  For now we are just ignoring the initial cellValues
+        //        and widths.  Add support for loading them from
+        //        Python sequence objects.
+        bool CreateGrid(int rows, int cols,
+                        //PyObject* cellValues  = NULL,
+                        //PyObject* widths      = NULL,
+                        short defaultWidth      = wxGRID_DEFAULT_CELL_WIDTH,
+                        short defaultHeight     = wxGRID_DEFAULT_CELL_HEIGHT) {
+            return self->CreateGrid(rows, cols, NULL, NULL,
+                                    defaultWidth, defaultHeight);
+        }
+    }
+
+    bool CurrentCellVisible();
+    bool DeleteCols(int pos=0, int n=1, bool updateLabels=TRUE);
+    bool DeleteRows(int pos=0, int n=1, bool updateLabels=TRUE);
+    void EndBatch();
+
+    int  GetBatchCount();
+    wxGridCell* GetCell(int row, int col);
+    int GetCellAlignment(int row, int col);
+    %name(GetDefCellAlignment)int GetCellAlignment();
+    wxColour& GetCellBackgroundColour(int row, int col);
+    %name(GetDefCellBackgroundColour)
+        wxColour& GetCellBackgroundColour();
+    //wxGridCell *** GetCells();
+    wxColour& GetCellTextColour(int row, int col);
+    %name(GetDefCellTextColour)wxColour& GetCellTextColour();
+    wxFont& GetCellTextFont(int row, int col);
+    %name(GetDefCellTextFont)wxFont& GetCellTextFont();
+    wxString& GetCellValue(int row, int col);
+    int GetCols();
+    int GetColumnWidth(int col);
+    wxRect& GetCurrentRect();
+    int GetCursorColumn();
+    int GetCursorRow();
+    bool GetEditable();
+    wxScrollBar * GetHorizScrollBar();
+    int GetLabelAlignment(int orientation);
+    wxColour& GetLabelBackgroundColour();
+    int GetLabelSize(int orientation);
+    wxColour& GetLabelTextColour();
+    wxFont& GetLabelTextFont();
+    wxString& GetLabelValue(int orientation, int pos);
+    int GetRowHeight(int row);
+    int GetRows();
+    int GetScrollPosX();
+    int GetScrollPosY();
+    wxTextCtrl* GetTextItem();
+    wxScrollBar* GetVertScrollBar();
+
+    bool InsertCols(int pos=0, int n=1, bool updateLabels=TRUE);
+    bool InsertRows(int pos=0, int n=1, bool updateLabels=TRUE);
+
+    void OnActivate(bool active);
+
+    void SetCellAlignment(int alignment, int row, int col);
+    %name(SetDefCellAlignment)void SetCellAlignment(int alignment);
+    void SetCellBackgroundColour(const wxColour& colour, int row, int col);
+    %name(SetDefCellBackgroundColour)
+        void SetCellBackgroundColour(const wxColour& colour);
+    void SetCellTextColour(const wxColour& colour, int row, int col);
+    %name(SetDefCellTextColour)void SetCellTextColour(const wxColour& colour);
+    void SetCellTextFont(wxFont& font, int row, int col);
+    %name(SetDefCellTextFont)void SetCellTextFont(wxFont& font);
+    void SetCellValue(const wxString& val, int row, int col);
+    void SetColumnWidth(int col, int width);
+    void SetDividerPen(wxPen& pen);
+    void SetEditable(bool editable);
+    void SetGridCursor(int row, int col);
+    void SetLabelAlignment(int orientation, int alignment);
+    void SetLabelBackgroundColour(const wxColour& value);
+    void SetLabelSize(int orientation, int size);
+    void SetLabelTextColour(const wxColour& value);
+    void SetLabelTextFont(wxFont& font);
+    void SetLabelValue(int orientation, const wxString& value, int pos);
+    void SetRowHeight(int row, int height);
+
+    void UpdateDimensions();
+};
+
+
+class wxGridEvent : public wxEvent {
+public:
+    int         m_row;
+    int         m_col;
+    int         m_x;
+    int         m_y;
+    bool        m_control;
+    bool        m_shift;
+    wxGridCell* m_cell;
+};
+
+
+enum {
+    wxEVT_GRID_SELECT_CELL,
+    wxEVT_GRID_CREATE_CELL,
+    wxEVT_GRID_CHANGE_LABELS,
+    wxEVT_GRID_CHANGE_SEL_LABEL,
+    wxEVT_GRID_CELL_CHANGE,
+    wxEVT_GRID_CELL_LCLICK,
+    wxEVT_GRID_CELL_RCLICK,
+    wxEVT_GRID_LABEL_LCLICK,
+    wxEVT_GRID_LABEL_RCLICK,
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxNotebookEvent : public wxCommandEvent {
+public:
+    int GetSelection();
+    int GetOldSelection();
+};
+
+
+
+class wxNotebook : public wxControl {
+public:
+    wxNotebook(wxWindow *parent,
+               wxWindowID id,
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = 0,
+               char* name = "notebook");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    int GetPageCount();
+    int SetSelection(int nPage);
+    void AdvanceSelection(bool bForward = TRUE);
+    int GetSelection();
+    bool SetPageText(int nPage, const wxString& strText);
+    wxString GetPageText(int nPage) const;
+    void SetImageList(wxImageList* imageList);
+    wxImageList* GetImageList();
+    int  GetPageImage(int nPage);
+    bool SetPageImage(int nPage, int nImage);
+    int GetRowCount();
+
+    // LINK ERROR: void SetPageSize(const wxSize& size);
+    // LINK ERROR: void SetPadding(const wxSize& padding);
+    bool DeletePage(int nPage);
+    bool DeleteAllPages();
+    bool AddPage(/*wxNotebookPage*/ wxWindow *pPage,
+                 const wxString& strText,
+                 bool bSelect = FALSE,
+                 int imageId = -1);
+#ifdef __WXMSW__
+    bool InsertPage(int nPage,
+                    /*wxNotebookPage*/ wxWindow *pPage,
+                    const wxString& strText,
+                    bool bSelect = FALSE,
+                    int imageId = -1);
+#endif
+    wxNotebookPage *GetPage(int nPage);
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxSplitterWindow : public wxWindow {
+public:
+    wxSplitterWindow(wxWindow* parent, wxWindowID id,
+                     const wxPoint& point = wxPyDefaultPosition,
+                     const wxSize& size = wxPyDefaultSize,
+                     long style=wxSP_3D|wxCLIP_CHILDREN,
+                     char* name = "splitterWindow");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    int GetBorderSize();
+    int GetMinimumPaneSize();
+    int GetSashPosition();
+    int GetSashSize();
+    int GetSplitMode();
+    wxWindow* GetWindow1();
+    wxWindow* GetWindow2();
+    void Initialize(wxWindow* window);
+    bool IsSplit();
+
+    // TODO:  How to handle callbacks that don't come from
+    //        event system???
+    //
+    //void OnDoubleClickSash(int x, int y);
+    //bool OnSashPositionChange(int newSashPosition);
+    //void OnUnsplit(wxWindow* removed);
+
+    void SetBorderSize(int width);
+    void SetSashPosition(int position, int redraw = TRUE);
+    void SetSashSize(int width);
+    void SetMinimumPaneSize(int paneSize);
+    void SetSplitMode(int mode);
+    bool SplitHorizontally(wxWindow* window1, wxWindow* window2, int sashPosition = 0);
+    bool SplitVertically(wxWindow* window1, wxWindow* window2, int sashPosition = 0);
+    bool Unsplit(wxWindow* toRemove = NULL);
+};
+
+//---------------------------------------------------------------------------
+
+#ifdef __WXMSW__
+
+enum {
+    wxEVT_TASKBAR_MOVE,
+    wxEVT_TASKBAR_LEFT_DOWN,
+    wxEVT_TASKBAR_LEFT_UP,
+    wxEVT_TASKBAR_RIGHT_DOWN,
+    wxEVT_TASKBAR_RIGHT_UP,
+    wxEVT_TASKBAR_LEFT_DCLICK,
+    wxEVT_TASKBAR_RIGHT_DCLICK
+};
+
+
+class wxTaskBarIcon : public wxEvtHandler {
+public:
+    wxTaskBarIcon();
+    ~wxTaskBarIcon();
+
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnMouseMove',    wxEVT_TASKBAR_MOVE)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonDown',  wxEVT_TASKBAR_LEFT_DOWN)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonUp',    wxEVT_TASKBAR_LEFT_UP)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonDown',  wxEVT_TASKBAR_RIGHT_DOWN)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonUp',    wxEVT_TASKBAR_RIGHT_UP)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnLButtonDClick',wxEVT_TASKBAR_LEFT_DCLICK)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnRButtonDClick',wxEVT_TASKBAR_RIGHT_DCLICK)"
+
+    bool SetIcon(const wxIcon& icon, const char* tooltip = "");
+    bool RemoveIcon(void);
+    bool PopupMenu(wxMenu *menu);
+
+};
+#endif
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.8  1998/12/17 18:05:53  RD
+// wxPython 0.5.2
+// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
+// versions are much closer now!
+//
+// Revision 1.7  1998/12/15 20:41:25  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.6  1998/11/25 08:45:28  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.5  1998/11/03 09:21:57  RD
+// fixed a typo
+//
+// Revision 1.4  1998/10/02 06:40:43  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:20  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:50  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:52  RD
+// Initial version
+//
+//

utils/wxPython/src/windows3.i

@@ -0,0 +1,193 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        windows3.i
+// Purpose:     SWIG definitions of MORE window classes
+//
+// Author:      Robin Dunn
+//
+// Created:     22-Dec-1998
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module windows3
+
+%{
+#include "helpers.h"
+#include <wx/sashwin.h>
+#include <wx/laywin.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import gdi.i
+%import windows.i
+%import windows2.i
+%import mdi.i
+%import events.i
+
+%pragma(python) code = "import wx"
+
+//---------------------------------------------------------------------------
+
+enum wxSashEdgePosition {
+    wxSASH_TOP = 0,
+    wxSASH_RIGHT,
+    wxSASH_BOTTOM,
+    wxSASH_LEFT,
+    wxSASH_NONE = 100
+};
+
+enum {
+    wxEVT_SASH_DRAGGED,
+    wxSW_3D,
+};
+
+enum wxSashDragStatus
+{
+    wxSASH_STATUS_OK,
+    wxSASH_STATUS_OUT_OF_RANGE
+};
+
+
+class wxSashEvent : public wxCommandEvent {
+public:
+    void SetEdge(wxSashEdgePosition edge);
+    wxSashEdgePosition GetEdge();
+    void SetDragRect(const wxRect& rect);
+    wxRect GetDragRect();
+    void SetDragStatus(wxSashDragStatus status);
+    wxSashDragStatus GetDragStatus();
+};
+
+
+
+class wxSashWindow: public wxWindow {
+public:
+    wxSashWindow(wxWindow* parent, wxWindowID id,
+                 const wxPoint& pos = wxPyDefaultPosition,
+                 const wxSize& size = wxPyDefaultSize,
+                 long style = wxCLIP_CHILDREN | wxSW_3D,
+                 const char* name = "sashWindow");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool GetSashVisible(wxSashEdgePosition edge);
+    int GetDefaultBorderSize();
+    int GetEdgeMargin(wxSashEdgePosition edge);
+    int GetExtraBorderSize();
+    int GetMaximumSizeX();
+    int GetMaximumSizeY();
+    int GetMinimumSizeX();
+    int GetMinimumSizeY();
+    bool HasBorder(wxSashEdgePosition edge);
+    void SetDefaultBorderSize(int width);
+    void SetExtraBorderSize(int width);
+    void SetMaximumSizeX(int min);
+    void SetMaximumSizeY(int min);
+    void SetMinimumSizeX(int min);
+    void SetMinimumSizeY(int min);
+    void SetSashVisible(wxSashEdgePosition edge, bool visible);
+    void SetSashBorder(wxSashEdgePosition edge, bool hasBorder);
+
+};
+
+
+//---------------------------------------------------------------------------
+
+enum wxLayoutOrientation {
+    wxLAYOUT_HORIZONTAL,
+    wxLAYOUT_VERTICAL
+};
+
+enum wxLayoutAlignment {
+    wxLAYOUT_NONE,
+    wxLAYOUT_TOP,
+    wxLAYOUT_LEFT,
+    wxLAYOUT_RIGHT,
+    wxLAYOUT_BOTTOM,
+};
+
+
+enum {
+     wxEVT_QUERY_LAYOUT_INFO,
+     wxEVT_CALCULATE_LAYOUT,
+};
+
+
+class wxQueryLayoutInfoEvent: public wxEvent {
+public:
+
+    void SetRequestedLength(int length);
+    int GetRequestedLength();
+    void SetFlags(int flags);
+    int GetFlags();
+    void SetSize(const wxSize& size);
+    wxSize GetSize();
+    void SetOrientation(wxLayoutOrientation orient);
+    wxLayoutOrientation GetOrientation();
+    void SetAlignment(wxLayoutAlignment align);
+    wxLayoutAlignment GetAlignment();
+};
+
+
+
+class wxCalculateLayoutEvent: public wxEvent {
+public:
+    void SetFlags(int flags);
+    int GetFlags();
+    void SetRect(const wxRect& rect);
+    wxRect GetRect();
+};
+
+
+class wxSashLayoutWindow: public wxSashWindow {
+public:
+    wxSashLayoutWindow(wxWindow* parent, wxWindowID id,
+                       const wxPoint& pos = wxPyDefaultPosition,
+                       const wxSize& size = wxPyDefaultSize,
+                       long style = wxCLIP_CHILDREN | wxSW_3D,
+                       const char* name = "layoutWindow");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnCalculateLayout',    wxEVT_CALCULATE_LAYOUT)"
+    %pragma(python) addtomethod = "__init__:wx._checkForCallback(self, 'OnQueryLayoutInfo',    wxEVT_QUERY_LAYOUT_INFO)"
+
+
+    wxLayoutAlignment GetAlignment();
+    wxLayoutOrientation GetOrientation();
+    void SetAlignment(wxLayoutAlignment alignment);
+    void SetDefaultSize(const wxSize& size);
+    void SetOrientation(wxLayoutOrientation orientation);
+};
+
+//---------------------------------------------------------------------------
+
+class wxLayoutAlgorithm {
+public:
+    wxLayoutAlgorithm();
+    ~wxLayoutAlgorithm();
+
+    bool LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* rect = NULL);
+    bool LayoutFrame(wxFrame* frame, wxWindow* mainWindow = NULL);
+};
+
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.1  1999/01/30 07:30:16  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+//
+//

utils/wxPython/src/wx.i

@@ -0,0 +1,235 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wxp.i
+// Purpose:     SWIG interface file for a python wxWindows module
+//
+// Author:      Robin Dunn
+//
+// Created:     5/22/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module wx
+
+
+%{
+#include "helpers.h"
+%}
+
+//----------------------------------------------------------------------
+// This is where we include the other wrapper definition files for SWIG
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+%include _defs.i
+
+%import misc.i
+%import windows.i
+%import events.i
+%import gdi.i
+%import mdi.i
+%import controls.i
+%import controls2.i
+%import windows2.i
+%import cmndlgs.i
+%import stattool.i
+%import frames.i
+%import windows3.i
+#ifndef SEPARATE
+%import utils.i
+#endif
+
+
+%native(_wxStart)           __wxStart;
+%native(_wxSetDictionary)   __wxSetDictionary;
+
+//---------------------------------------------------------------------------
+
+#define __version__ "0.5.4"
+
+wxPoint     wxPyDefaultPosition;
+wxSize      wxPyDefaultSize;
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+
+class wxPyApp : public wxEvtHandler {
+public:
+    %addmethods {
+        wxPyApp() {
+            wxPythonApp = new wxPyApp();
+            return wxPythonApp;
+        }
+    }
+
+
+    wxString GetAppName();
+#ifdef __WXMSW__
+    bool GetAuto3D();
+#endif
+    wxString GetClassName();
+    bool GetExitOnFrameDelete();
+    int GetPrintMode();
+    wxWindow * GetTopWindow();
+    wxString GetVendorName();
+
+    void Dispatch();
+    void ExitMainLoop();
+    bool Initialized();
+    int  MainLoop();
+    bool Pending();
+
+    void SetAppName(const wxString& name);
+#ifdef __WXMSW__
+    void SetAuto3D(bool auto3D);
+#endif
+    void SetClassName(const wxString& name);
+    void SetExitOnFrameDelete(bool flag);
+    void SetPrintMode(int mode);
+    void SetTopWindow(wxWindow* window);
+    void SetVendorName(const wxString& name);
+
+    // This one is wxPython specific.  If you override MainLoop,
+    // call this when done.
+    void AfterMainLoop();
+};
+
+
+
+//----------------------------------------------------------------------
+// This code gets added to the module initialization function
+//----------------------------------------------------------------------
+
+%{
+extern "C" SWIGEXPORT(void,initwindowsc)();
+extern "C" SWIGEXPORT(void,initwindows2c)();
+extern "C" SWIGEXPORT(void,initeventsc)();
+extern "C" SWIGEXPORT(void,initmiscc)();
+extern "C" SWIGEXPORT(void,initgdic)();
+extern "C" SWIGEXPORT(void,initmdic)();
+extern "C" SWIGEXPORT(void,initcontrolsc)();
+extern "C" SWIGEXPORT(void,initcontrols2c)();
+extern "C" SWIGEXPORT(void,initcmndlgsc)();
+extern "C" SWIGEXPORT(void,initstattoolc)();
+extern "C" SWIGEXPORT(void,initframesc)();
+extern "C" SWIGEXPORT(void,initutilsc)();
+extern "C" SWIGEXPORT(void,initwindows3c)();
+
+
+%}
+
+%init %{
+
+    __wxPreStart();     // initialize the GUI toolkit, if needed.
+
+//    wxPyWindows = new wxHashTable(wxKEY_INTEGER, 100);
+
+        // Since these modules are all linked together, initialize them now
+        // because python won't be able to find their shared library files,
+        // (since there isn't any.)
+    initwindowsc();
+    initwindows2c();
+    initeventsc();
+    initmiscc();
+    initgdic();
+    initmdic();
+    initcontrolsc();
+    initcontrols2c();
+    initcmndlgsc();
+    initstattoolc();
+    initframesc();
+    initwindows3c();
+#ifndef SEPARATE
+    initutilsc();
+#endif
+%}
+
+//----------------------------------------------------------------------
+// And this gets appended to the shadow class file.
+//----------------------------------------------------------------------
+
+%pragma(python) include="_extras.py";
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.5  1999/02/01 00:10:41  RD
+// Added the missing EVT_LIST_ITEM_SELECTED and friends.
+//
+// Revision 1.4  1999/01/30 07:30:16  RD
+//
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.3  1998/12/17 17:52:21  RD
+//
+// wxPython 0.5.2
+// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
+// versions are much closer now!
+//
+// Revision 1.2  1998/12/16 22:10:57  RD
+//
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.1  1998/12/15 20:41:27  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.9  1998/10/20 07:38:04  RD
+// bug fix
+//
+// Revision 1.8  1998/10/07 07:34:35  RD
+// Version 0.4.1 for wxGTK
+//
+// Revision 1.7  1998/10/02 06:40:44  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.6  1998/08/27 21:59:10  RD
+// Some chicken-and-egg problems solved for wxPython on wxGTK
+//
+// Revision 1.5  1998/08/27 00:00:28  RD
+// - more tweaks
+// - have discovered some problems but not yet discovered solutions...
+//
+// Revision 1.4  1998/08/18 19:48:20  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.3  1998/08/15 07:36:53  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.2  1998/08/14 23:36:49  RD
+// Beginings of wxGTK compatibility
+//
+// Revision 1.1  1998/08/09 08:25:53  RD
+// Initial version
+//
+//
+
+

utils/wxPython/src/wxc.def

@@ -0,0 +1,2 @@
+EXPORTS
+  initwxc

utils/wxPython/src/wxc.rc

@@ -0,0 +1,2 @@
+wxpicon ICON "wxp.ico"
+#include "wx/msw/wx.rc"