Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial version

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@485 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
1998-08-09 08:31:08 +00:00
parent b6a69abc7d
commit 7bf854050f
51 changed files with 49938 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
utils/wxPython/README.txt Normal file
View File

@@ -0,0 +1,133 @@
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 wan 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.
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.
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 an 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 in the src directory.
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 bulid 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 USE_RESOURCE_LOADING_IN_MSW set to 1 in
include/wx/msw/setup.h so icons can be loaded dynamically.
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 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
----
NOTE: I don't have wxPython working yet with wxGTK, so if you aren't
using Win32 you can skip the rest of this file and check back in a
week or so.
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.
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
------------------------
8/8/1998
Robin Dunn
robind@earthling.net

34
utils/wxPython/TODO.txt Normal file
View File

@@ -0,0 +1,34 @@
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 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.
3. Derived Python classes should have the ability to call the standard
On** methods in the base class.
4. 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?
5. Add the Doc/View related classes
6. Add the Printing related classes
7. Document the differences (method signatures, new methods to
compensate for no overloading, etc.) between wxPython and wxWindows.
8.

377
utils/wxPython/src/Makefile.pre.in Normal file
View File

@@ -0,0 +1,377 @@
# 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
# === 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 defaul 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 $(srcdir)/Setup.in Setup
# Make the intermediate Makefile.pre from Makefile.pre.in
Makefile.pre: Makefile.pre.in sedscript
sed -f sedscript $(srcdir)/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 $(srcdir)/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
ifndef FINAL
PYEXT=pyc
PYTHON=python
else
PYEXT=pyo
PYTHON=python -O
endif
PYMODULES = wxp.py events.py windows.py misc.py \
gdi.py mdi.py controls.py controls2.py \
windows2.py cmndlgs.py __init__.py
# Implicit rules to run SWIG
%.cpp : %.i
swig $(SWIGFLAGS) -c -o $*.cpp $*.i
$(TARGETDIR)/%.py : %.py
cp $< $@
$(TARGETDIR)/%.$(PYEXT) : %.py
$(PYTHON) -c "import py_compile; py_compile.compile('$<', '$@')"
%.py : %.i
swig $(SWIGFLAGS) -c -o $*.cpp $*.i
# This one must leave out the -c flag so we define the whole rule
wxp.cpp wxp.py : wxp.i my_typemaps.i _defs.i _extras.py
swig $(SWIGFLAGS) -o wxp.cpp wxp.i
# define some dependencies
windows.cpp windows.py : windows.i my_typemaps.i _defs.i
windows2.cpp windows2.py : windows2.i my_typemaps.i _defs.i
events.cpp events.py : events.i my_typemaps.i _defs.i
misc.cpp misc.py : misc.i my_typemaps.i _defs.i
gdi.cpp gdi.py : gdi.i my_typemaps.i _defs.i
mdi.cpp mdi.py : mdi.i my_typemaps.i _defs.i
controls.cpp controls.py : controls.i my_typemaps.i _defs.i
controls2.cpp controls2.py : controls2.i my_typemaps.i _defs.i
cmndlgs.cpp cmndlgs.py : cmndlgs.i my_typemaps.i _defs.i
wxInstall : sharedmods $(PYMODULES)
if test ! -d $(TARGETDIR) ; then \
mkdir $(TARGETDIR) ; else true ; fi
-for i in $(SHAREDMODS); do \
$(INSTALL_SHARED) $$i $(TARGETDIR)/$$i; \
done
-for i in $(PYMODULES); do \
$(INSTALL) $$i $(TARGETDIR)/$$i; \
done
python $(LIBDEST)/compileall.py -l $(TARGETDIR)
python -O $(LIBDEST)/compileall.py -l $(TARGETDIR)

18
utils/wxPython/src/Setup.in Normal file
View File

@@ -0,0 +1,18 @@
# This file gives the details of what is needed to uild this extension
# module so the Makefile can be created.
*shared*
CCC=c++
WXWIN=../../..
## Pick one of these, or set your own
#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
TARGETDIR=..
wxpc wxp.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
-I$(WXWIN)/include -I/usr/lib/glib/include \
-DSWIG_GLOBAL -D__WXGTK__ -L$(WXWIN)/lib/Linux -lwx_gtk

24
utils/wxPython/src/__init__.py Normal file
View File

@@ -0,0 +1,24 @@
#----------------------------------------------------------------------------
# Name: __init__.py
# Purpose: The presence of this file turs this directory into a
# Python package. For simplicity, we import all of the
# wxPython package at this point, so users only need to
# import the package.
#
# Author: Robin Dunn
#
# Created: 8/8/98
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
from wxp import *
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.1 1998/08/09 08:25:49 RD
# Initial version
#
#

704
utils/wxPython/src/_defs.i Normal file
View File

@@ -0,0 +1,704 @@
/////////////////////////////////////////////////////////////////////////////
// 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;
//---------------------------------------------------------------------------
// 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,
UNKNOWN,
NOT_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,
wxRETAINED,
wxBACKINGSTORE,
wxTB_3DBUTTONS,
wxTB_HORIZONTAL,
wxTB_VERTICAL,
wxCOLOURED,
wxFIXED_LENGTH,
wxALIGN_LEFT,
wxALIGN_CENTER,
wxALIGN_CENTRE,
wxALIGN_RIGHT,
wxSB_MASK,
wxNEEDED_SB,
wxALWAYS_SB,
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,
wxREADONLY,
wxEDITABLE,
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,
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,
wxDF_TEXT,
wxDF_BITMAP,
wxDF_METAFILE,
wxDF_DIB,
wxDF_OEMTEXT,
wxDF_FILENAME,
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_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
//#ifdef __X__
// /* 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_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.1 1998/08/09 08:25:49 RD
// Initial version
//
//

767
utils/wxPython/src/_extras.py Normal file
View File

@@ -0,0 +1,767 @@
#----------------------------------------------------------------------------
# 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 _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)
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)
#----------------------------------------------------------------------
#----------------------------------------------------------------------
# We need to add to the shadow classes a bit to facilitate callbacks via
# virtual functions. These classes replace the shadows generated by SWIG.
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
_StdWindowCallbacks(self)
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(windowsc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
self.thisown = 1
_StdFrameCallbacks(self)
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(windowsc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
self.thisown = 1
_StdFrameCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
_checkForCallback(self, "OnOk", wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK)
_checkForCallback(self, "OnApply", wxEVT_COMMAND_BUTTON_CLICKED, wxID_APPLY)
_checkForCallback(self, "OnCancel", wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL)
_checkForCallback(self, "OnCloseWindow", wxEVT_CLOSE_WINDOW)
_checkForCallback(self, "OnCharHook", wxEVT_CHAR_HOOK)
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
_StdWindowCallbacks(self)
_StdOnScrollCallback(self)
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
_StdFrameCallbacks(self)
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
_StdFrameCallbacks(self)
class wxMDIClientWindow(wxMDIClientWindowPtr):
def __init__(self,arg0,*args) :
self.this = apply(mdic.new_wxMDIClientWindow,(arg0.this,)+args)
self.thisown = 1
_StdWindowCallbacks(self)
_StdOnScrollCallback(self)
class wxControl(wxControlPtr):
def __init__(self,this):
self.this = this
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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
_StdWindowCallbacks(self)
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)
#----------------------------------------------------------------------
## 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 == '__WIN32__')
#----------------------------------------------------------------------
# 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.1 1998/08/09 08:25:49 RD
# Initial version
#
#

3842
utils/wxPython/src/cmndlgs.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

293
utils/wxPython/src/cmndlgs.i Normal file
View File

@@ -0,0 +1,293 @@
%module cmndlgs
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#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
//----------------------------------------------------------------------
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);
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);
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);
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);
}
}
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);
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);
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);
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);
wxPrintData& GetPrintData();
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);
int ShowModal();
};
//----------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.1 1998/08/09 08:25:49 RD
// Initial version
//
//

580
utils/wxPython/src/cmndlgs.py Normal file
View File

@@ -0,0 +1,580 @@
# This file was created automatically by SWIG.
import cmndlgsc
from misc import *
from gdi import *
from windows import *
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)
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
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
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
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
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
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
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
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)
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
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
#-------------- FUNCTION WRAPPERS ------------------
#-------------- VARIABLE WRAPPERS ------------------

5679
utils/wxPython/src/controls.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

426
utils/wxPython/src/controls.i Normal file
View File

@@ -0,0 +1,426 @@
%module controls
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#include "helpers.h"
#include <wx/slider.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
%import windows.i
%import gdi.i
%import events.i
//----------------------------------------------------------------------
%{
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");
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");
wxBitmap& GetBitmapDisabled();
wxBitmap& GetBitmapFocus();
wxBitmap& GetBitmapLabel();
wxBitmap& GetBitmapSelected();
void SetBitmapDisabled(const wxBitmap& bitmap);
void SetBitmapFocus(const wxBitmap& bitmap);
void SetBitmapLabel(const wxBitmap& bitmap);
void SetBitmapSelected(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");
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");
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");
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");
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");
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");
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 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");
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");
int GetRange();
int GetPageSize();
int GetPosition();
int GetThumbSize();
void SetPosition(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");
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");
%name(EnableBox)void Enable(bool enable);
void Enable(int n, bool enable);
int FindString(const wxString& string);
%name(GetBoxLabel)wxString GetLabel();
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");
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");
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.1 1998/08/09 08:25:49 RD
// Initial version
//
//

794
utils/wxPython/src/controls.py Normal file
View File

@@ -0,0 +1,794 @@
# This file was created automatically by SWIG.
import controlsc
from misc import *
from windows import *
from gdi import *
from events import *
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
class wxBitmapButtonPtr(wxButtonPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
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 GetBitmapLabel(self):
val = controlsc.wxBitmapButton_GetBitmapLabel(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 SetBitmapLabel(self,arg0):
val = controlsc.wxBitmapButton_SetBitmapLabel(self.this,arg0.this)
return val
def SetBitmapSelected(self,arg0):
val = controlsc.wxBitmapButton_SetBitmapSelected(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
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
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
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
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
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
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
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
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 GetPosition(self):
val = controlsc.wxScrollBar_GetPosition(self.this)
return val
def GetThumbSize(self):
val = controlsc.wxScrollBar_GetThumbSize(self.this)
return val
def SetPosition(self,arg0):
val = controlsc.wxScrollBar_SetPosition(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
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
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
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
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
#-------------- FUNCTION WRAPPERS ------------------
#-------------- VARIABLE WRAPPERS ------------------

4239
utils/wxPython/src/controls2.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

381
utils/wxPython/src/controls2.i Normal file
View File

@@ -0,0 +1,381 @@
%module controls2
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#include "helpers.h"
#include <wx/listctrl.h>
#include <wx/treectrl.h>
#include <wx/tabctrl.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
//----------------------------------------------------------------------
%{
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");
bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
bool DeleteItem(long item);
bool DeleteAllItems();
bool DeleteColumn(int col);
bool DeleteAllColumns(void);
void ClearAll(void);
wxTextCtrl* EditLabel(long item);
bool EndEditLabel(bool cancel);
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();
wxTextCtrl* GetEditControl();
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();
wxColour GetTextColour();
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 SetTextColour(const wxColour& col);
void SetWindowStyleFlag(long style);
// TODO: bool SortItems(wxListCtrlCompare fn, long data);
};
//----------------------------------------------------------------------
enum {
wxTREE_MASK_HANDLE,
wxTREE_MASK_STATE,
wxTREE_MASK_TEXT,
wxTREE_MASK_IMAGE,
wxTREE_MASK_SELECTED_IMAGE,
wxTREE_MASK_CHILDREN,
wxTREE_MASK_DATA,
wxTREE_STATE_BOLD,
wxTREE_STATE_DROPHILITED,
wxTREE_STATE_EXPANDED,
wxTREE_STATE_EXPANDEDONCE,
wxTREE_STATE_FOCUSED,
wxTREE_STATE_SELECTED,
wxTREE_STATE_CUT,
wxTREE_HITTEST_ABOVE,
wxTREE_HITTEST_BELOW,
wxTREE_HITTEST_NOWHERE,
wxTREE_HITTEST_ONITEMBUTTON,
wxTREE_HITTEST_ONITEMICON,
wxTREE_HITTEST_ONITEMINDENT,
wxTREE_HITTEST_ONITEMLABEL,
wxTREE_HITTEST_ONITEMRIGHT,
wxTREE_HITTEST_ONITEMSTATEICON,
wxTREE_HITTEST_TOLEFT,
wxTREE_HITTEST_TORIGHT,
wxTREE_HITTEST_ONITEM,
};
enum {
wxTREE_NEXT_CARET,
wxTREE_NEXT_CHILD,
wxTREE_NEXT_DROPHILITE,
wxTREE_NEXT_FIRSTVISIBLE,
wxTREE_NEXT_NEXT,
wxTREE_NEXT_NEXTVISIBLE,
wxTREE_NEXT_PARENT,
wxTREE_NEXT_PREVIOUS,
wxTREE_NEXT_PREVIOUSVISIBLE,
wxTREE_NEXT_ROOT
};
enum {
wxTREE_EXPAND_EXPAND,
wxTREE_EXPAND_COLLAPSE,
wxTREE_EXPAND_COLLAPSE_RESET,
wxTREE_EXPAND_TOGGLE
};
enum {
wxTREE_INSERT_LAST,
wxTREE_INSERT_FIRST,
wxTREE_INSERT_SORT,
};
class wxTreeItem {
public:
long m_mask;
long m_itemId;
long m_state;
long m_stateMask;
wxString m_text;
int m_image;
int m_selectedImage;
int m_children;
long m_data;
wxTreeItem();
~wxTreeItem();
};
class wxTreeEvent : public wxCommandEvent {
public:
int m_code;
wxTreeItem m_item;
long m_oldItem;
wxPoint m_pointDrag;
};
class wxTreeCtrl : public wxControl {
public:
wxTreeCtrl(wxWindow *parent, wxWindowID id = -1,
const wxPoint& pos = wxPyDefaultPosition,
const wxSize& size = wxPyDefaultSize,
long style = wxTR_HAS_BUTTONS,
const wxValidator& validator = wxPyDefaultValidator,
char* name = "wxTreeCtrl");
bool DeleteAllItems();
bool DeleteItem(long item);
wxTextCtrl* EditLabel(long item);
bool EnsureVisible(long item);
bool ExpandItem(long item, int action);
long GetChild(long item);
int GetCount();
wxTextCtrl* GetEditControl();
long GetFirstVisibleItem();
wxImageList* GetImageList(int which = wxIMAGE_LIST_NORMAL);
int GetIndent();
long GetItemData(long item);
%addmethods {
%new wxTreeItem* GetItem() {
wxTreeItem* info = new wxTreeItem;
self->GetItem(*info);
return info;
}
%new wxRect* GetItemRect(long item, int textOnly = FALSE) {
wxRect* rect = new wxRect;
self->GetItemRect(item, *rect, textOnly);
return rect;
}
}
int GetItemState(long item, long stateMask);
wxString GetItemText(long item);
long GetNextItem(long item, int code);
long GetNextVisibleItem(long item);
long GetParent(long item);
long GetRootItem();
long GetSelection();
long HitTest(const wxPoint& point, int& OUTPUT); // *** check this
long InsertItem(long parent, wxTreeItem& info,
long insertAfter = wxTREE_INSERT_LAST);
%name(InsertItemString)
long InsertItem(long parent, const wxString& label,
int image = -1, int selImage = -1,
long insertAfter = wxTREE_INSERT_LAST);
bool ItemHasChildren(long item);
bool ScrollTo(long item);
bool SelectItem(long item);
void SetIndent(int indent);
void SetImageList(wxImageList* imageList, int which = wxIMAGE_LIST_NORMAL);
bool SetItem(wxTreeItem& info);
bool SetItemImage(long item, int image, int selImage);
bool SetItemState(long item, long state, long stateMask);
void SetItemText(long item, const wxString& text);
bool SetItemData(long item, long data);
bool SortChildren(long item);
};
//----------------------------------------------------------------------
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");
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);
};
//----------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.1 1998/08/09 08:25:49 RD
// Initial version
//
//

689
utils/wxPython/src/controls2.py Normal file
View File

@@ -0,0 +1,689 @@
# This file was created automatically by SWIG.
import controls2c
from misc import *
from windows import *
from gdi import *
from events import *
from controls import *
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 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 GetEditControl(self):
val = controls2c.wxListCtrl_GetEditControl(self.this)
val = wxTextCtrlPtr(val)
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 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 SetTextColour(self,arg0):
val = controls2c.wxListCtrl_SetTextColour(self.this,arg0.this)
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
class wxTreeItemPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self):
if self.thisown == 1 :
controls2c.delete_wxTreeItem(self.this)
def __setattr__(self,name,value):
if name == "m_mask" :
controls2c.wxTreeItem_m_mask_set(self.this,value)
return
if name == "m_itemId" :
controls2c.wxTreeItem_m_itemId_set(self.this,value)
return
if name == "m_state" :
controls2c.wxTreeItem_m_state_set(self.this,value)
return
if name == "m_stateMask" :
controls2c.wxTreeItem_m_stateMask_set(self.this,value)
return
if name == "m_text" :
controls2c.wxTreeItem_m_text_set(self.this,value)
return
if name == "m_image" :
controls2c.wxTreeItem_m_image_set(self.this,value)
return
if name == "m_selectedImage" :
controls2c.wxTreeItem_m_selectedImage_set(self.this,value)
return
if name == "m_children" :
controls2c.wxTreeItem_m_children_set(self.this,value)
return
if name == "m_data" :
controls2c.wxTreeItem_m_data_set(self.this,value)
return
self.__dict__[name] = value
def __getattr__(self,name):
if name == "m_mask" :
return controls2c.wxTreeItem_m_mask_get(self.this)
if name == "m_itemId" :
return controls2c.wxTreeItem_m_itemId_get(self.this)
if name == "m_state" :
return controls2c.wxTreeItem_m_state_get(self.this)
if name == "m_stateMask" :
return controls2c.wxTreeItem_m_stateMask_get(self.this)
if name == "m_text" :
return controls2c.wxTreeItem_m_text_get(self.this)
if name == "m_image" :
return controls2c.wxTreeItem_m_image_get(self.this)
if name == "m_selectedImage" :
return controls2c.wxTreeItem_m_selectedImage_get(self.this)
if name == "m_children" :
return controls2c.wxTreeItem_m_children_get(self.this)
if name == "m_data" :
return controls2c.wxTreeItem_m_data_get(self.this)
raise AttributeError,name
def __repr__(self):
return "<C wxTreeItem instance>"
class wxTreeItem(wxTreeItemPtr):
def __init__(self) :
self.this = controls2c.new_wxTreeItem()
self.thisown = 1
class wxTreeEventPtr(wxCommandEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def __setattr__(self,name,value):
if name == "m_code" :
controls2c.wxTreeEvent_m_code_set(self.this,value)
return
if name == "m_item" :
controls2c.wxTreeEvent_m_item_set(self.this,value.this)
return
if name == "m_oldItem" :
controls2c.wxTreeEvent_m_oldItem_set(self.this,value)
return
if name == "m_pointDrag" :
controls2c.wxTreeEvent_m_pointDrag_set(self.this,value.this)
return
self.__dict__[name] = value
def __getattr__(self,name):
if name == "m_code" :
return controls2c.wxTreeEvent_m_code_get(self.this)
if name == "m_item" :
return wxTreeItemPtr(controls2c.wxTreeEvent_m_item_get(self.this))
if name == "m_oldItem" :
return controls2c.wxTreeEvent_m_oldItem_get(self.this)
if name == "m_pointDrag" :
return wxPointPtr(controls2c.wxTreeEvent_m_pointDrag_get(self.this))
raise AttributeError,name
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 DeleteAllItems(self):
val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
return val
def DeleteItem(self,arg0):
val = controls2c.wxTreeCtrl_DeleteItem(self.this,arg0)
return val
def EditLabel(self,arg0):
val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0)
val = wxTextCtrlPtr(val)
return val
def EnsureVisible(self,arg0):
val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0)
return val
def ExpandItem(self,arg0,arg1):
val = controls2c.wxTreeCtrl_ExpandItem(self.this,arg0,arg1)
return val
def GetChild(self,arg0):
val = controls2c.wxTreeCtrl_GetChild(self.this,arg0)
return val
def GetCount(self):
val = controls2c.wxTreeCtrl_GetCount(self.this)
return val
def GetEditControl(self):
val = controls2c.wxTreeCtrl_GetEditControl(self.this)
val = wxTextCtrlPtr(val)
return val
def GetFirstVisibleItem(self):
val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
return val
def GetImageList(self,*args):
val = apply(controls2c.wxTreeCtrl_GetImageList,(self.this,)+args)
return val
def GetIndent(self):
val = controls2c.wxTreeCtrl_GetIndent(self.this)
return val
def GetItemData(self,arg0):
val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0)
return val
def GetItem(self):
val = controls2c.wxTreeCtrl_GetItem(self.this)
val = wxTreeItemPtr(val)
val.thisown = 1
return val
def GetItemRect(self,arg0,*args):
val = apply(controls2c.wxTreeCtrl_GetItemRect,(self.this,arg0,)+args)
val = wxRectPtr(val)
val.thisown = 1
return val
def GetItemState(self,arg0,arg1):
val = controls2c.wxTreeCtrl_GetItemState(self.this,arg0,arg1)
return val
def GetItemText(self,arg0):
val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0)
return val
def GetNextItem(self,arg0,arg1):
val = controls2c.wxTreeCtrl_GetNextItem(self.this,arg0,arg1)
return val
def GetNextVisibleItem(self,arg0):
val = controls2c.wxTreeCtrl_GetNextVisibleItem(self.this,arg0)
return val
def GetParent(self,arg0):
val = controls2c.wxTreeCtrl_GetParent(self.this,arg0)
return val
def GetRootItem(self):
val = controls2c.wxTreeCtrl_GetRootItem(self.this)
return val
def GetSelection(self):
val = controls2c.wxTreeCtrl_GetSelection(self.this)
return val
def HitTest(self,arg0):
val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
return val
def InsertItem(self,arg0,arg1,*args):
val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0,arg1.this,)+args)
return val
def InsertItemString(self,arg0,arg1,*args):
val = apply(controls2c.wxTreeCtrl_InsertItemString,(self.this,arg0,arg1,)+args)
return val
def ItemHasChildren(self,arg0):
val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0)
return val
def ScrollTo(self,arg0):
val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0)
return val
def SelectItem(self,arg0):
val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0)
return val
def SetIndent(self,arg0):
val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
return val
def SetImageList(self,arg0,*args):
val = apply(controls2c.wxTreeCtrl_SetImageList,(self.this,arg0,)+args)
return val
def SetItem(self,arg0):
val = controls2c.wxTreeCtrl_SetItem(self.this,arg0.this)
return val
def SetItemImage(self,arg0,arg1,arg2):
val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0,arg1,arg2)
return val
def SetItemState(self,arg0,arg1,arg2):
val = controls2c.wxTreeCtrl_SetItemState(self.this,arg0,arg1,arg2)
return val
def SetItemText(self,arg0,arg1):
val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0,arg1)
return val
def SetItemData(self,arg0,arg1):
val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0,arg1)
return val
def SortChildren(self,arg0):
val = controls2c.wxTreeCtrl_SortChildren(self.this,arg0)
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
class wxTabEventPtr(wxCommandEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def __repr__(self):
return "<C wxTabEvent instance>"
class wxTabEvent(wxTabEventPtr):
def __init__(self,this):
self.this = this
class wxTabCtrlPtr(wxControlPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def DeleteAllItems(self):
val = controls2c.wxTabCtrl_DeleteAllItems(self.this)
return val
def DeleteItem(self,arg0):
val = controls2c.wxTabCtrl_DeleteItem(self.this,arg0)
return val
def GetImageList(self):
val = controls2c.wxTabCtrl_GetImageList(self.this)
return val
def GetItemCount(self):
val = controls2c.wxTabCtrl_GetItemCount(self.this)
return val
def GetItemImage(self,arg0):
val = controls2c.wxTabCtrl_GetItemImage(self.this,arg0)
return val
def GetItemRect(self,arg0):
val = controls2c.wxTabCtrl_GetItemRect(self.this,arg0)
val = wxRectPtr(val)
val.thisown = 1
return val
def GetItemText(self,arg0):
val = controls2c.wxTabCtrl_GetItemText(self.this,arg0)
return val
def GetRowCount(self):
val = controls2c.wxTabCtrl_GetRowCount(self.this)
return val
def GetSelection(self):
val = controls2c.wxTabCtrl_GetSelection(self.this)
return val
def HitTest(self,arg0):
val = controls2c.wxTabCtrl_HitTest(self.this,arg0.this)
return val
def InsertItem(self,arg0,arg1,*args):
val = apply(controls2c.wxTabCtrl_InsertItem,(self.this,arg0,arg1,)+args)
return val
def SetItemImage(self,arg0,arg1):
val = controls2c.wxTabCtrl_SetItemImage(self.this,arg0,arg1)
return val
def SetImageList(self,arg0):
val = controls2c.wxTabCtrl_SetImageList(self.this,arg0)
return val
def SetItemSize(self,arg0):
val = controls2c.wxTabCtrl_SetItemSize(self.this,arg0.this)
return val
def SetItemText(self,arg0,arg1):
val = controls2c.wxTabCtrl_SetItemText(self.this,arg0,arg1)
return val
def SetPadding(self,arg0):
val = controls2c.wxTabCtrl_SetPadding(self.this,arg0.this)
return val
def SetSelection(self,arg0):
val = controls2c.wxTabCtrl_SetSelection(self.this,arg0)
return val
def __repr__(self):
return "<C wxTabCtrl instance>"
class wxTabCtrl(wxTabCtrlPtr):
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_wxTabCtrl,(arg0.this,arg1,)+args)
self.thisown = 1
#-------------- FUNCTION WRAPPERS ------------------
#-------------- VARIABLE WRAPPERS ------------------
wxTREE_MASK_HANDLE = controls2c.wxTREE_MASK_HANDLE
wxTREE_MASK_STATE = controls2c.wxTREE_MASK_STATE
wxTREE_MASK_TEXT = controls2c.wxTREE_MASK_TEXT
wxTREE_MASK_IMAGE = controls2c.wxTREE_MASK_IMAGE
wxTREE_MASK_SELECTED_IMAGE = controls2c.wxTREE_MASK_SELECTED_IMAGE
wxTREE_MASK_CHILDREN = controls2c.wxTREE_MASK_CHILDREN
wxTREE_MASK_DATA = controls2c.wxTREE_MASK_DATA
wxTREE_STATE_BOLD = controls2c.wxTREE_STATE_BOLD
wxTREE_STATE_DROPHILITED = controls2c.wxTREE_STATE_DROPHILITED
wxTREE_STATE_EXPANDED = controls2c.wxTREE_STATE_EXPANDED
wxTREE_STATE_EXPANDEDONCE = controls2c.wxTREE_STATE_EXPANDEDONCE
wxTREE_STATE_FOCUSED = controls2c.wxTREE_STATE_FOCUSED
wxTREE_STATE_SELECTED = controls2c.wxTREE_STATE_SELECTED
wxTREE_STATE_CUT = controls2c.wxTREE_STATE_CUT
wxTREE_HITTEST_ABOVE = controls2c.wxTREE_HITTEST_ABOVE
wxTREE_HITTEST_BELOW = controls2c.wxTREE_HITTEST_BELOW
wxTREE_HITTEST_NOWHERE = controls2c.wxTREE_HITTEST_NOWHERE
wxTREE_HITTEST_ONITEMBUTTON = controls2c.wxTREE_HITTEST_ONITEMBUTTON
wxTREE_HITTEST_ONITEMICON = controls2c.wxTREE_HITTEST_ONITEMICON
wxTREE_HITTEST_ONITEMINDENT = controls2c.wxTREE_HITTEST_ONITEMINDENT
wxTREE_HITTEST_ONITEMLABEL = controls2c.wxTREE_HITTEST_ONITEMLABEL
wxTREE_HITTEST_ONITEMRIGHT = controls2c.wxTREE_HITTEST_ONITEMRIGHT
wxTREE_HITTEST_ONITEMSTATEICON = controls2c.wxTREE_HITTEST_ONITEMSTATEICON
wxTREE_HITTEST_TOLEFT = controls2c.wxTREE_HITTEST_TOLEFT
wxTREE_HITTEST_TORIGHT = controls2c.wxTREE_HITTEST_TORIGHT
wxTREE_HITTEST_ONITEM = controls2c.wxTREE_HITTEST_ONITEM
wxTREE_NEXT_CARET = controls2c.wxTREE_NEXT_CARET
wxTREE_NEXT_CHILD = controls2c.wxTREE_NEXT_CHILD
wxTREE_NEXT_DROPHILITE = controls2c.wxTREE_NEXT_DROPHILITE
wxTREE_NEXT_FIRSTVISIBLE = controls2c.wxTREE_NEXT_FIRSTVISIBLE
wxTREE_NEXT_NEXT = controls2c.wxTREE_NEXT_NEXT
wxTREE_NEXT_NEXTVISIBLE = controls2c.wxTREE_NEXT_NEXTVISIBLE
wxTREE_NEXT_PARENT = controls2c.wxTREE_NEXT_PARENT
wxTREE_NEXT_PREVIOUS = controls2c.wxTREE_NEXT_PREVIOUS
wxTREE_NEXT_PREVIOUSVISIBLE = controls2c.wxTREE_NEXT_PREVIOUSVISIBLE
wxTREE_NEXT_ROOT = controls2c.wxTREE_NEXT_ROOT
wxTREE_EXPAND_EXPAND = controls2c.wxTREE_EXPAND_EXPAND
wxTREE_EXPAND_COLLAPSE = controls2c.wxTREE_EXPAND_COLLAPSE
wxTREE_EXPAND_COLLAPSE_RESET = controls2c.wxTREE_EXPAND_COLLAPSE_RESET
wxTREE_EXPAND_TOGGLE = controls2c.wxTREE_EXPAND_TOGGLE
wxTREE_INSERT_LAST = controls2c.wxTREE_INSERT_LAST
wxTREE_INSERT_FIRST = controls2c.wxTREE_INSERT_FIRST
wxTREE_INSERT_SORT = controls2c.wxTREE_INSERT_SORT

2858
utils/wxPython/src/events.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

295
utils/wxPython/src/events.i Normal file
View File

@@ -0,0 +1,295 @@
%module events
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#include "helpers.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 GetSessionEnding();
bool GetLoggingOff();
void Veto(bool veto = TRUE);
bool GetVeto();
void SetForce(bool force);
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 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.1 1998/08/09 08:25:50 RD
// Initial version
//
//

611
utils/wxPython/src/events.py Normal file
View File

@@ -0,0 +1,611 @@
# 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 GetSessionEnding(self):
val = eventsc.wxCloseEvent_GetSessionEnding(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 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 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 ------------------

5398
utils/wxPython/src/gdi.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

466
utils/wxPython/src/gdi.i Normal file
View File

@@ -0,0 +1,466 @@
%module gdi
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#include "helpers.h"
#include <wx/metafile.h>
%}
//----------------------------------------------------------------------
%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();
void Create(int width, int height, int depth = -1);
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);
void SetOk(int isOk);
void SetPalette(wxPalette* palette);
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:
wxIcon(char *name, long flags);
~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 SetOk(int isOk);
void SetWidth(int width);
};
//---------------------------------------------------------------------------
class wxCursor : public wxBitmap {
public:
wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
~wxCursor();
bool Ok();
};
%new wxCursor* wxStockCursor(int id);
%{ // Alternate 'constructor'
wxCursor* wxStockCursor(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();
int GetFontId();
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();
// **** This one needs to return a list of ints (wxDash)
int GetDashes(wxDash **dashes);
int GetJoin();
wxBitmap* GetStipple();
int GetStyle();
int GetWidth();
bool Ok();
void SetCap(int cap_style);
void SetColour(wxColour& colour);
void SetDashes(int LCOUNT, wxDash* LIST);
void SetJoin(int join_style);
void SetStipple(wxBitmap * stipple);
void SetStyle(int style);
void SetWidth(int width);
};
//----------------------------------------------------------------------
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();
~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();
//bool GetPixel(int x, int y, wxColour *T_OUTPUT); **** See below.
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 {
%new wxColour* GetPixel(long x, long y) {
wxColor* wc = new wxColor();
self->GetPixel(x, y, wc);
return wc;
}
// 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 wxPostScriptDC : public wxDC {
public:
wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
};
//---------------------------------------------------------------------------
class wxPrinterDC : public wxDC {
public:
wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
bool interactive = TRUE, int orientation = wxPORTRAIT);
};
//---------------------------------------------------------------------------
class wxMetaFileDC : public wxDC {
public:
wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
wxMetaFile* Close();
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
%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;
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.1 1998/08/09 08:25:50 RD
// Initial version
//
//

775
utils/wxPython/src/gdi.py Normal file
View File

@@ -0,0 +1,775 @@
# 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)
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):
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 SetOk(self,arg0):
val = gdic.wxBitmap_SetOk(self.this,arg0)
return val
def SetPalette(self,arg0):
val = gdic.wxBitmap_SetPalette(self.this,arg0)
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 SetOk(self,arg0):
val = gdic.wxIcon_SetOk(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) :
self.this = gdic.new_wxIcon(arg0,arg1)
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 GetDashes(self,arg0):
val = gdic.wxPen_GetDashes(self.this,arg0)
return val
def GetJoin(self):
val = gdic.wxPen_GetJoin(self.this)
return val
def GetStipple(self):
val = gdic.wxPen_GetStipple(self.this)
val = wxBitmapPtr(val)
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 SetDashes(self,arg0,*args):
val = apply(gdic.wxPen_SetDashes,(self.this,arg0,)+args)
return val
def SetJoin(self,arg0):
val = gdic.wxPen_SetJoin(self.this,arg0)
return val
def SetStipple(self,arg0):
val = gdic.wxPen_SetStipple(self.this,arg0.this)
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 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)
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 GetPixel(self,arg0,arg1):
val = gdic.wxDC_GetPixel(self.this,arg0,arg1)
val = wxColourPtr(val)
val.thisown = 1
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) :
self.this = gdic.new_wxDC()
self.thisown = 1
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 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 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
#-------------- 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)

1058
utils/wxPython/src/helpers.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

110
utils/wxPython/src/helpers.h Normal file
View File

@@ -0,0 +1,110 @@
/////////////////////////////////////////////////////////////////////////////
// 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;
//----------------------------------------------------------------------
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
// Non-const versions to keep SWIG happy.
extern wxPoint wxPyDefaultPosition;
extern wxSize wxPyDefaultSize;
extern char* wxPyPanelNameStr;
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.1 1998/08/09 08:25:51 RD
// Initial version
//
//
#endif

184
utils/wxPython/src/makefile.nt Normal file
View File

@@ -0,0 +1,184 @@
#----------------------------------------------------------------------------
# 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
#----------------------------------------------------------------------------
# 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.
TARGETDIR=..
#----------------------------------------------------------------------
WXUSINGDLL=0
NOPCH=1
THISDIR=$(WXDIR)\utils\wxPython
EXTRALIBS=$(PYTHONDIR)\libs\python15.lib
EXTRAINC=-I$(PYTHONDIR)\include
EXTRAFLAGS=/Fpwxp.pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H
SWIGFLAGS=-c++ -shadow -python -dnone
!include $(WXDIR)\src\ntwxwin.mak
#----------------------------------------------------------------------
TARGET = wxpc
OBJECTS = wxp.obj helpers.obj windows.obj events.obj \
misc.obj gdi.obj mdi.obj controls.obj \
controls2.obj windows2.obj cmndlgs.obj
PYMODULES = $(TARGETDIR)\wxp.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)\__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
#----------------------------------------------------------------------
default: $(TARGETDIR)\$(TARGET).pyd pycfiles
all: wx $(TARGET)
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)
$(PYTHONDIR)\python $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
$(PYTHONDIR)\python -O $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
#----------------------------------------------------------------------
$(TARGETDIR)\$(TARGET).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(TARGET).res
$(link) @<<
/out:$@ /dll
$(LFLAGS)
$(DUMMYOBJ) $(OBJECTS) $(TARGET).res
$(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 $<
<<
clean:
-erase *.obj
-erase *.exe
-erase *.res
-erase *.map
-erase *.sbr
-erase *.pdb
-erase *.pch
-erase $(TARGET).exp
-erase $(TARGET).lib
-erase $(TARGETDIR)\$(TARGET).pyd
-erase $(TARGETDIR)\*.py
-erase $(TARGETDIR)\*.pyc
-erase $(TARGETDIR)\*.pyo
-erase $(TARGETDIR)\$(TARGET).*
#------------------------------------------------------------------------
.SUFFIXES : .i .py
# Implicit rules to run SWIG
{}.i{}.cpp:
swig $(SWIGFLAGS) -c -o $*.cpp $*.i
{}.i{}.py:
swig $(SWIGFLAGS) -c -o $*.cpp $*.i
{}.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
wxp.cpp wxp.py : wxp.i my_typemaps.i _defs.i _extras.py
swig $(SWIGFLAGS) -o wxp.cpp wxp.i
# define some dependencies
windows.cpp windows.py : windows.i my_typemaps.i _defs.i
windows2.cpp windows2.py : windows2.i my_typemaps.i _defs.i
events.cpp events.py : events.i my_typemaps.i _defs.i
misc.cpp misc.py : misc.i my_typemaps.i _defs.i
gdi.cpp gdi.py : gdi.i my_typemaps.i _defs.i
mdi.cpp mdi.py : mdi.i my_typemaps.i _defs.i
controls.cpp controls.py : controls.i my_typemaps.i _defs.i
controls2.cpp controls2.py : controls2.i my_typemaps.i _defs.i
cmndlgs.cpp cmndlgs.py : cmndlgs.i my_typemaps.i _defs.i
$(TARGETDIR)\wxp.py : wxp.py
$(TARGETDIR)\windows.py : windows.py
$(TARGETDIR)\windows2.py : windows2.py
$(TARGETDIR)\events.py : events.py
$(TARGETDIR)\misc.py : misc.py
$(TARGETDIR)\gdi.py : gdi.py
$(TARGETDIR)\mdi.py : mdi.py
$(TARGETDIR)\controls.py : controls.py
$(TARGETDIR)\controls2.py : controls2.py
$(TARGETDIR)\cmndlgs.py : cmndlgs.py
#------------------------------------------------------------------------
#
# $Log$
# Revision 1.1 1998/08/09 08:25:51 RD
# Initial version
#

817
utils/wxPython/src/mdi.cpp Normal file
View File

@@ -0,0 +1,817 @@
/*
* FILE : 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"
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#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 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;
}
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_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("_signed_long","_long",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("_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("_byte","_unsigned_char",0);
SWIG_RegisterMapping("_long","_wxDash",0);
SWIG_RegisterMapping("_long","_unsigned_long",0);
SWIG_RegisterMapping("_long","_signed_long",0);
SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
SWIG_RegisterMapping("_wxPrinterDC","_class_wxPrinterDC",0);
SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
SWIG_RegisterMapping("_class_wxPostScriptDC","_wxPostScriptDC",0);
SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
SWIG_RegisterMapping("_uint","_wxWindowID",0);
SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
SWIG_RegisterMapping("_wxFont","_class_wxFont",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("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
SWIG_RegisterMapping("_wxMetaFileDC","_class_wxMetaFileDC",0);
SWIG_RegisterMapping("_wxMenu","_class_wxMenu",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_wxFont","_wxFont",0);
SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",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_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_wxMetaFileDC","_wxMetaFileDC",0);
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",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("_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("_wxSize","_class_wxSize",0);
SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",0);
SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0);
SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0);
SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",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("_wxDash","_unsigned_long",0);
SWIG_RegisterMapping("_wxDash","_long",0);
SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",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);
}

89
utils/wxPython/src/mdi.i Normal file
View File

@@ -0,0 +1,89 @@
%module mdi
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#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
//----------------------------------------------------------------------
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");
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();
void SetToolBar(wxToolBar* toolbar);
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");
void Activate();
void Maximize();
void Restore();
};
//---------------------------------------------------------------------------
class wxMDIClientWindow : public wxWindow {
public:
wxMDIClientWindow(wxMDIParentFrame* parent, long style = 0);
};
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.1 1998/08/09 08:25:51 RD
// Initial version
//
//

112
utils/wxPython/src/mdi.py Normal file
View File

@@ -0,0 +1,112 @@
# This file was created automatically by SWIG.
import mdic
from misc import *
from windows import *
from gdi import *
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)
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
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 __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
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
#-------------- FUNCTION WRAPPERS ------------------
#-------------- VARIABLE WRAPPERS ------------------

2975
utils/wxPython/src/misc.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

309
utils/wxPython/src/misc.i Normal file
View File

@@ -0,0 +1,309 @@
%module misc
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#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
char* 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);
wxWindow * wxGetActiveWindow();
long wxGetElapsedTime(bool resetTimer = TRUE);
long wxGetFreeMemory();
void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
bool wxIsBusy();
wxString wxNow();
bool wxShell(const wxString& command = wxPyEmptyStr);
void wxStartTimer();
bool wxYield();
int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
%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);
void Below(wxWindow *otherWin, int margin=0);
void Unconstrained(void);
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
}
//---------------------------------------------------------------------------
// 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.1 1998/08/09 08:25:51 RD
// Initial version
//
//

532
utils/wxPython/src/misc.py Normal file
View File

@@ -0,0 +1,532 @@
# 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 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
wxYield = miscc.wxYield
wxGetOsVersion = miscc.wxGetOsVersion
wxGetResource = miscc.wxGetResource
wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
wxResourceClear = miscc.wxResourceClear
def wxResourceCreateBitmap(arg0):
val = miscc.wxResourceCreateBitmap(arg0)
val = wxBitmapPtr(val)
return val
def wxResourceCreateIcon(arg0):
val = miscc.wxResourceCreateIcon(arg0)
val = wxIconPtr(val)
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

193
utils/wxPython/src/my_typemaps.i Normal file
View File

@@ -0,0 +1,193 @@
/////////////////////////////////////////////////////////////////////////////
// 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 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) 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.1 1998/08/09 08:25:52 RD
// Initial version
//
//

5000
utils/wxPython/src/windows.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

358
utils/wxPython/src/windows.i Normal file
View File

@@ -0,0 +1,358 @@
%module windows
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#include "helpers.h"
#include <wx/minifram.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
//---------------------------------------------------------------------------
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");
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();
void DragAcceptFiles(bool accept);
void Enable(bool enable);
//bool FakePopupMenu(wxMenu* menu, int x, int y);
void Fit();
wxColour GetBackgroundColour();
int GetCharHeight();
int GetCharWidth();
void GetClientSize(int *OUTPUT, int *OUTPUT);
wxLayoutConstraints * GetConstraints();
wxButton* GetDefaultItem();
//wxEvtHandler* GetEventHandler();
wxFont* GetFont();
wxColour GetForegroundColour();
wxWindow * GetGrandParent();
int GetId();
void GetPosition(int *OUTPUT, int *OUTPUT);
wxString& GetLabel();
wxString& GetName();
wxWindow * GetParent();
int GetReturnCode();
int GetScrollThumb(int orientation);
int GetScrollPos(int orientation);
int GetScrollRange(int orientation);
void GetSize(int *OUTPUT, int *OUTPUT);
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 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 SetColourMap(wxColourMap *colourMap);
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);
};
// Static method(s)
%inline %{
wxWindow* wxWindow_FindFocus() {
return wxWindow::FindFocus();
}
%}
//----------------------------------------------------------------------
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");
void Centre(int direction = wxBOTH);
void Command(int id);
bool CreateStatusBar(int number = 1);
wxMenuBar* GetMenuBar();
wxStatusBar* GetStatusBar();
wxString& GetTitle();
void Iconize(bool iconize);
bool IsIconized();
// *** removed *** void LoadAccelerators(const wxString& table);
void SetAcceleratorTable(const wxAcceleratorTable& accel);
void Maximize(bool maximize);
void SetIcon(const wxIcon& icon);
void SetMenuBar(wxMenuBar* menuBar);
void SetStatusText(const wxString& text, int number = 0);
void SetStatusWidths(int LCOUNT, int* LIST); // use typemap
void SetTitle(const wxString& title);
};
//---------------------------------------------------------------------------
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");
};
//---------------------------------------------------------------------------
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");
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");
void Centre(int direction = wxBOTH);
void EndModal(int retCode);
wxString GetTitle();
void Iconize(bool iconize);
bool IsIconized();
bool IsModal();
void SetModal(bool flag);
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");
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);
bool Checked(int id);
void Enable(int id, bool enable);
int FindItem(const wxString& itemString);
wxMenuItem* FindItemForId(int id);
wxString& GetHelpString(int id);
wxString GetLabel(int id);
wxString GetTitle();
void SetHelpString(int id, const wxString& helpString);
void SetLabel(int id, const wxString& label);
void SetTitle(const wxString& title);
};
//
// 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);
void EnableTop(int pos, bool enable);
int FindMenuItem(const wxString& menuString, const wxString& itemString);
wxMenuItem * FindItemForId(int id);
wxString GetHelpString(int id);
wxString GetLabel(int id);
wxString GetLabelTop(int pos);
void SetHelpString(int id, const wxString& helpString);
void SetLabel(int id, const wxString& label);
void SetLabelTop(int pos, const wxString& label);
};
//----------------------------------------------------------------------
class wxMenuItem {
public:
bool IsSeparator();
bool IsEnabled();
bool IsChecked();
int GetId();
const wxString& GetHelp();
wxMenu* GetSubMenu();
void SetName(const wxString& strName);
void SetHelp(const wxString& strHelp);
void Enable(bool bDoEnable = TRUE);
void Check(bool bDoCheck = TRUE);
void DeleteSubMenu();
const wxString& GetName();
bool IsCheckable();
};
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.1 1998/08/09 08:25:52 RD
// Initial version
//
//

672
utils/wxPython/src/windows.py Normal file
View File

@@ -0,0 +1,672 @@
# This file was created automatically by SWIG.
import windowsc
from misc import *
from gdi import *
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 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 GetClientSize(self):
val = windowsc.wxWindow_GetClientSize(self.this)
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 GetPosition(self):
val = windowsc.wxWindow_GetPosition(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 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 GetSize(self):
val = windowsc.wxWindow_GetSize(self.this)
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 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 __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
class wxFramePtr(wxWindowPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def Centre(self,*args):
val = apply(windowsc.wxFrame_Centre,(self.this,)+args)
return val
def Command(self,arg0):
val = windowsc.wxFrame_Command(self.this,arg0)
return val
def CreateStatusBar(self,*args):
val = apply(windowsc.wxFrame_CreateStatusBar,(self.this,)+args)
return val
def GetMenuBar(self):
val = windowsc.wxFrame_GetMenuBar(self.this)
val = wxMenuBarPtr(val)
return val
def GetStatusBar(self):
val = windowsc.wxFrame_GetStatusBar(self.this)
return val
def GetTitle(self):
val = windowsc.wxFrame_GetTitle(self.this)
return val
def Iconize(self,arg0):
val = windowsc.wxFrame_Iconize(self.this,arg0)
return val
def IsIconized(self):
val = windowsc.wxFrame_IsIconized(self.this)
return val
def SetAcceleratorTable(self,arg0):
val = windowsc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
return val
def Maximize(self,arg0):
val = windowsc.wxFrame_Maximize(self.this,arg0)
return val
def SetIcon(self,arg0):
val = windowsc.wxFrame_SetIcon(self.this,arg0.this)
return val
def SetMenuBar(self,arg0):
val = windowsc.wxFrame_SetMenuBar(self.this,arg0.this)
return val
def SetStatusText(self,arg0,*args):
val = apply(windowsc.wxFrame_SetStatusText,(self.this,arg0,)+args)
return val
def SetStatusWidths(self,arg0,*args):
val = apply(windowsc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
return val
def SetTitle(self,arg0):
val = windowsc.wxFrame_SetTitle(self.this,arg0)
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(windowsc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
self.thisown = 1
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(windowsc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
self.thisown = 1
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
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 IsModal(self):
val = windowsc.wxDialog_IsModal(self.this)
return val
def SetModal(self,arg0):
val = windowsc.wxDialog_SetModal(self.this,arg0)
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
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
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 Checked(self,arg0):
val = windowsc.wxMenu_Checked(self.this,arg0)
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 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 GetTitle(self):
val = windowsc.wxMenu_GetTitle(self.this)
return val
def SetHelpString(self,arg0,arg1):
val = windowsc.wxMenu_SetHelpString(self.this,arg0,arg1)
return val
def SetLabel(self,arg0,arg1):
val = windowsc.wxMenu_SetLabel(self.this,arg0,arg1)
return val
def SetTitle(self,arg0):
val = windowsc.wxMenu_SetTitle(self.this,arg0)
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 EnableTop(self,arg0,arg1):
val = windowsc.wxMenuBar_EnableTop(self.this,arg0,arg1)
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 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 GetLabelTop(self,arg0):
val = windowsc.wxMenuBar_GetLabelTop(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 SetLabelTop(self,arg0,arg1):
val = windowsc.wxMenuBar_SetLabelTop(self.this,arg0,arg1)
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 GetId(self):
val = windowsc.wxMenuItem_GetId(self.this)
return val
def GetHelp(self):
val = windowsc.wxMenuItem_GetHelp(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 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 GetName(self):
val = windowsc.wxMenuItem_GetName(self.this)
return val
def IsCheckable(self):
val = windowsc.wxMenuItem_IsCheckable(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 ------------------

3001
utils/wxPython/src/windows2.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

228
utils/wxPython/src/windows2.i Normal file
View File

@@ -0,0 +1,228 @@
%module windows2
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#include "helpers.h"
#include <wx/grid.h>
#include <wx/notebook.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 controls.i
%import events.i
//---------------------------------------------------------------------------
enum {
wxGRID_TEXT_CTRL,
wxGRID_HSCROLL,
wxGRID_VSCROLL,
};
class wxGridCell {
public:
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");
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);
// TODO: How to handle callbacks that don't come from
// event system???
//
//void OnActivate(bool active);
//void OnChangeLabels();
//void OnChangeSelectionLabel();
//wxGridCell* OnCreateCell();
//void OnLeftClick(int row, int col, int x, int y, bool control, bool shift);
//void OnRightClick(int row, int col, int x, int y, bool control, bool shift);
//void OnLabelLeftClick(int row, int col, int x, int y, bool control, bool shift);
//void OnLabelRightClick(int row, int col, int x, int y, bool control, bool shift);
//void OnSelectCell(int row, int col);
//void OnSelectCellImplementation(wxDC *dc, int row, int col);
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 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");
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);
bool InsertPage(int nPage,
/*wxNotebookPage*/ wxWindow *pPage,
const wxString& strText,
bool bSelect = FALSE,
int imageId = -1);
wxNotebookPage *GetPage(int nPage);
};
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.1 1998/08/09 08:25:52 RD
// Initial version
//
//

390
utils/wxPython/src/windows2.py Normal file
View File

@@ -0,0 +1,390 @@
# This file was created automatically by SWIG.
import windows2c
from misc import *
from gdi import *
from windows import *
from controls import *
from events import *
class wxGridCellPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
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,this):
self.this = this
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 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
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
#-------------- FUNCTION WRAPPERS ------------------
#-------------- VARIABLE WRAPPERS ------------------
wxGRID_TEXT_CTRL = windows2c.wxGRID_TEXT_CTRL
wxGRID_HSCROLL = windows2c.wxGRID_HSCROLL
wxGRID_VSCROLL = windows2c.wxGRID_VSCROLL

2046
utils/wxPython/src/wxp.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

184
utils/wxPython/src/wxp.i Normal file
View File

@@ -0,0 +1,184 @@
%module wxp
%{
/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////
#ifdef __WXMSW__
#include <windows.h>
#undef FindWindow
#undef GetCharWidth
#undef LoadAccelerators
#endif
#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
%native(_wxStart) __wxStart;
%native(_wxSetDictionary) __wxSetDictionary;
//---------------------------------------------------------------------------
#define __version__ "0.3.0"
//%readonly
wxPoint wxPyDefaultPosition;
wxSize wxPyDefaultSize;
//%readwrite
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class wxPyApp : public wxEvtHandler {
public:
%addmethods {
wxPyApp() {
wxPythonApp = new wxPyApp();
return wxPythonApp;
}
}
wxString GetAppName();
bool GetAuto3D();
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);
void SetAuto3D(bool auto3D);
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();
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
%{
#ifdef __WXMSW__ // If building for win32...
extern HINSTANCE wxhInstance;
BOOL WINAPI DllMain(
HINSTANCE hinstDLL, // handle to DLL module
DWORD fdwReason, // reason for calling function
LPVOID lpvReserved // reserved
)
{
wxhInstance = hinstDLL;
return 1;
}
#endif
%}
//----------------------------------------------------------------------
// 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)();
%}
%init %{
// We don't want to run the wxEntry or OnInit yet, so we just do the
// beginings of what it would have done... See __wxStart() for the
// rest.
#ifdef __WXMSW__
wxApp::Initialize((WXHINSTANCE)wxhInstance);
#endif
#ifdef __WXGTK__
wxApp::CommonInit();
#endif
// 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();
%}
//----------------------------------------------------------------------
// And this gets appended to the shadow class file.
//----------------------------------------------------------------------
%pragma(python) include="_extras.py";
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.1 1998/08/09 08:25:53 RD
// Initial version
//
//

BIN
utils/wxPython/src/wxp.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 766 B

1392
utils/wxPython/src/wxp.py Normal file
View File

File diff suppressed because it is too large Load Diff

2
utils/wxPython/src/wxpc.def Normal file
View File

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

2
utils/wxPython/src/wxpc.rc Normal file
View File

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

BIN
utils/wxPython/tests/bitmaps/mondrian.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 766 B

BIN
utils/wxPython/tests/bitmaps/test2.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

1
utils/wxPython/tests/setup.bat Executable file
View File

@@ -0,0 +1 @@
set PYTHONPATH=e:\projects\wxWindows\utils

72
utils/wxPython/tests/test1.py Normal file
View File

@@ -0,0 +1,72 @@
#!/bin/env python
#----------------------------------------------------------------------------
# Name: test1.py
# Purpose: A minimal wxPython program
#
# Author: Robin Dunn
#
# Created:
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
from wxPython import *
#---------------------------------------------------------------------------
class MyFrame(wxFrame):
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent, id, title, wxPoint(100, 100), wxSize(160, 100))
self.Connect(-1, -1, wxEVT_MOVE, self.OnMove)
def OnCloseWindow(self, event):
self.Destroy()
def OnSize(self, event):
size = event.GetSize()
print "size:", size.width, size.height
def OnMove(self, event):
# Hmmm... Doesn't seem to be implmented in wxWin yet...
pos = event.GetPosition()
print "pos:", pos.x, pos.y
#---------------------------------------------------------------------------
class MyApp(wxApp):
def OnInit(self):
frame = MyFrame(NULL, -1, "This is a test")
frame.Show(true)
self.SetTopWindow(frame)
return true
#---------------------------------------------------------------------------
def main():
app = MyApp(0)
app.MainLoop()
def t():
import pdb
pdb.run('main()')
if __name__ == '__main__':
main()
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.1 1998/08/09 08:28:05 RD
# Initial version
#
#

158
utils/wxPython/tests/test2.py Normal file
View File

@@ -0,0 +1,158 @@
#!/bin/env python
#----------------------------------------------------------------------------
# Name: test2.py
# Purpose: Testing GDI stuff and events.
#
# Author: Robin Dunn
#
# Created:
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
from wxPython import *
#---------------------------------------------------------------------------
class MyCanvas(wxWindow):
def __init__(self, parent):
wxWindow.__init__(self, parent, -1, wxPoint(0, 0), wxPyDefaultSize, wxSUNKEN_BORDER)
self.Connect(-1, -1, wxEVT_LEFT_DOWN, self.OnLeftButtonEvent)
self.Connect(-1, -1, wxEVT_LEFT_UP, self.OnLeftButtonEvent)
self.Connect(-1, -1, wxEVT_MOTION, self.OnLeftButtonEvent)
self.SetCursor(wxStockCursor(wxCURSOR_PENCIL))
bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP)
print 'bmp OK:', bmp.Ok()
print 'bmp: (%dx%dx%d)' % (bmp.GetWidth(), bmp.GetHeight(), bmp.GetDepth())
self.bmp = bmp
self.lines = []
def OnPaint(self, event):
dc = wxPaintDC(self)
self.DoDrawing(dc)
def DoDrawing(self, dc):
dc.BeginDrawing()
#dc.Clear()
pen1 = wxPen(wxNamedColour('RED'))
dc.SetPen(pen1)
dc.DrawRectangle(5, 5, 50, 50)
dc.SetBrush(wxLIGHT_GREY_BRUSH)
dc.SetPen(wxPen(wxNamedColour('BLUE'), 4))
dc.DrawRectangle(15, 15, 50, 50)
font = wxFont(14, wxSWISS, wxNORMAL, wxNORMAL)
dc.SetFont(font)
dc.SetTextForeground(wxColour(0xFF, 0x20, 0xFF))
te = dc.GetTextExtent("Hello World")
dc.DrawText("Hello World", 60, 65)
dc.SetPen(wxPen(wxNamedColour('VIOLET'), 4))
dc.DrawLine(5, 65+te[1], 60+te[0], 65+te[1])
lst = [(100,110), (150,110), (150,160), (100,160)]
dc.DrawLines(lst, -60)
dc.SetPen(wxGREY_PEN)
dc.DrawPolygon(lst, 75)
dc.SetPen(wxGREEN_PEN)
dc.DrawSpline(lst+[(100,100)])
dc.DrawBitmap(self.bmp, 200, 20)
dc.SetTextForeground(wxColour(0, 0xFF, 0x80))
dc.DrawText("a bitmap", 200, 80)
self.DrawSavedLines(dc)
dc.EndDrawing()
def DrawSavedLines(self, dc):
dc.SetPen(wxPen(wxNamedColour('MEDIUM FOREST GREEN'), 4))
for line in self.lines:
for coords in line:
apply(dc.DrawLine, coords)
def OnLeftButtonEvent(self, event):
if event.LeftDown():
self.x, self.y = event.GetX(), event.GetY()
self.curLine = []
elif event.Dragging():
dc = wxClientDC(self)
dc.BeginDrawing()
dc.SetPen(wxPen(wxNamedColour('MEDIUM FOREST GREEN'), 4))
coords = (self.x, self.y, event.GetX(), event.GetY())
self.curLine.append(coords)
apply(dc.DrawLine, coords)
self.x, self.y = event.GetX(), event.GetY()
dc.EndDrawing()
elif event.LeftUp():
self.lines.append(self.curLine)
self.curLine = []
#---------------------------------------------------------------------------
class MyFrame(wxFrame):
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition, wxSize(320, 200))
self.canvas = MyCanvas(self)
def OnCloseWindow(self, event):
self.Destroy()
def OnSize(self, event):
w,h = self.GetClientSize()
#self.canvas.SetSize(5, 5, w-10, h-10)
self.canvas.SetDimensions(0, 0, w, h)
#---------------------------------------------------------------------------
class MyApp(wxApp):
def OnInit(self):
frame = MyFrame(NULL, -1, "Test 2")
frame.Show(true)
self.SetTopWindow(frame)
return true
#---------------------------------------------------------------------------
def main():
app = MyApp(0)
app.MainLoop()
def t():
import pdb
pdb.run('main()')
if __name__ == '__main__':
main()
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.1 1998/08/09 08:28:05 RD
# Initial version
#
#

144
utils/wxPython/tests/test3.py Normal file
View File

@@ -0,0 +1,144 @@
#!/bin/env python
#----------------------------------------------------------------------------
# Name: test3.py
# Purpose: Testing menus and status lines
#
# Author: Robin Dunn
#
# Created:
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
from wxPython import *
#---------------------------------------------------------------------------
class MyCanvas(wxWindow):
def OnPaint(self, event):
dc = wxPaintDC(self)
dc.BeginDrawing()
w, h = self.GetClientSize()
font = wxFont(42, wxSWISS, wxNORMAL, wxNORMAL)
dc.SetFont(font)
st = "Python Rules!"
tw,th, d,e = dc.GetTextExtent(st)
dc.DrawText(st, (w-tw)/2, (h-th)/2)
dc.EndDrawing()
#---------------------------------------------------------------------------
class MyMiniFrame(wxMiniFrame):
def __init__(self, parent, ID, title, pos, size, style):
wxMiniFrame.__init__(self, parent, ID, title, pos, size, style)
panel = wxPanel(self, -1)
ID = NewId()
button = wxButton(panel, ID, "Close Me")
button.SetPosition(wxPoint(15, 15))
self.Connect(ID, -1, wxEVT_COMMAND_BUTTON_CLICKED, self.OnCloseMe)
def OnCloseMe(self, event):
self.Close(true)
def OnCloseWindow(self, event):
self.Destroy()
#---------------------------------------------------------------------------
class MyFrame(wxFrame):
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
wxSize(420, 200))
self.canvas = MyCanvas(self, -1)
self.CreateStatusBar(3)
mainmenu = wxMenuBar()
menu = wxMenu()
menu.Append(100, 'A &Menu Item', 'the help text')
menu.Append(101, '&Another', 'Grok!')
menu.AppendSeparator()
menu.Append(200, 'E&xit', 'Get the heck outta here!')
mainmenu.Append(menu, "&It's a menu!")
self.SetMenuBar(mainmenu)
print menu.GetHelpString(100)
print mainmenu.GetHelpString(101)
print mainmenu.GetHelpString(200)
self.DragAcceptFiles(true)
self.Connect(-1, -1, wxEVT_COMMAND_MENU_SELECTED, self.OnMenuCommand)
self.Connect(-1, -1, wxEVT_DROP_FILES, self.OnDropFiles)
def OnCloseWindow(self, event):
print 'OnCloseWindow'
self.Destroy()
def OnSize(self, event):
w,h = self.GetClientSize()
self.canvas.SetSize(wxSize(w, h))
self.SetStatusText("hello, this is a test: (%d, %d)" % (w,h))
## def OnMenuHighlight(self, event):
## mainmenu = self.GetMenuBar()
## st = mainmenu.GetHelpString(event.GetMenuId())
## self.SetStatusText('['+st+']', 0)
def OnMenuCommand(self, event):
# why isn't this a wxMenuEvent???
print event, event.GetInt()
if event.GetInt() == 200:
self.Close()
elif event.GetInt() == 101:
win = MyMiniFrame(self, -1, "This is a Mini...",
wxPoint(-1, -1), #wxPyDefaultPosition,
wxSize(150, 150),
wxMINIMIZE_BOX | wxMAXIMIZE_BOX |
wxTHICK_FRAME | wxSYSTEM_MENU |
wxTINY_CAPTION_HORIZ)
win.Show(true)
def OnDropFiles(self, event):
fileList = event.GetFiles()
for file in fileList:
print file
#---------------------------------------------------------------------------
class MyApp(wxApp):
def OnInit(self):
frame = MyFrame(NULL, -1, "Test 3")
frame.Show(true)
self.SetTopWindow(frame)
return true
#---------------------------------------------------------------------------
def main():
app = MyApp(0)
app.MainLoop()
def t():
import pdb
pdb.run('main()')
if __name__ == '__main__':
main()
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.1 1998/08/09 08:28:05 RD
# Initial version
#
#

526
utils/wxPython/tests/test4.py Normal file
View File

@@ -0,0 +1,526 @@
#!/bin/env python
#----------------------------------------------------------------------------
# Name: test4.py
# Purpose: Testing lots of stuff, controls, window types, etc.
#
# Author: Robin Dunn
#
# Created:
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
from wxPython import *
#---------------------------------------------------------------------------
class TestSimpleControlsDlg(wxDialog):
def __init__(self, parent, log):
self.log = log
wxDialog.__init__(self, parent, -1, "Test Simple Controls",
wxPyDefaultPosition, wxSize(350, 350))
sampleList = ['zero', 'one', 'two', 'three', 'four', 'five',
'six', 'seven', 'eight']
y_pos = 5
delta = 25
wxStaticText(self, -1, "wxTextCtrl", wxPoint(5, y_pos), wxSize(75, 20))
wxTextCtrl(self, 10, "", wxPoint(80, y_pos), wxSize(150, 20))
EVT_TEXT(self, 10, self.EvtText)
y_pos = y_pos + delta
wxCheckBox(self, 20, "wxCheckBox", wxPoint(80, y_pos), wxSize(150, 20))
EVT_CHECKBOX(self, 20, self.EvtCheckBox)
y_pos = y_pos + delta
rb = wxRadioBox(self, 30, "wxRadioBox", wxPoint(80, y_pos), wxPyDefaultSize,
sampleList, 3, wxRA_HORIZONTAL)
EVT_RADIOBOX(self, 30, self.EvtRadioBox)
width, height = rb.GetSize()
y_pos = y_pos + height + 5
wxStaticText(self, -1, "wxChoice", wxPoint(5, y_pos), wxSize(75, 20))
wxChoice(self, 40, wxPoint(80, y_pos), wxSize(95, 20), #wxPyDefaultSize,
sampleList)
EVT_CHOICE(self, 40, self.EvtChoice)
y_pos = y_pos + delta
wxStaticText(self, -1, "wxComboBox", wxPoint(5, y_pos), wxSize(75, 18))
wxComboBox(self, 50, "default value", wxPoint(80, y_pos), wxSize(95, 20),
sampleList, wxCB_DROPDOWN)
EVT_COMBOBOX(self, 50, self.EvtComboBox)
y_pos = y_pos + delta
wxStaticText(self, -1, "wxListBox", wxPoint(5, y_pos), wxSize(75, 18))
lb = wxListBox(self, 60, wxPoint(80, y_pos), wxPyDefaultSize,
sampleList, wxLB_SINGLE)
EVT_LISTBOX(self, 60, self.EvtListBox)
EVT_LISTBOX_DCLICK(self, 60, self.EvtListBoxDClick)
lb.SetSelection(0)
width, height = lb.GetSize()
y_pos = y_pos + height + 5
y_pos = y_pos + 15
wxButton(self, wxID_OK, ' OK ', wxPoint(80, y_pos), wxPyDefaultSize).SetDefault()
wxButton(self, wxID_CANCEL, ' Cancel ', wxPoint(140, y_pos))
def EvtText(self, event):
self.log.WriteText('EvtText: %s\n' % event.GetString())
def EvtCheckBox(self, event):
self.log.WriteText('EvtCheckBox: %d\n' % event.GetInt())
def EvtRadioBox(self, event):
self.log.WriteText('EvtRadioBox: %d\n' % event.GetInt())
def EvtChoice(self, event):
self.log.WriteText('EvtChoice: %s\n' % event.GetString())
def EvtComboBox(self, event):
self.log.WriteText('EvtComboBox: %s\n' % event.GetString())
def EvtListBox(self, event):
self.log.WriteText('EvtListBox: %s\n' % event.GetString())
def EvtListBoxDClick(self, event):
self.log.WriteText('EvtListBoxDClick:\n')
#---------------------------------------------------------------------------
class TestTimer(wxTimer):
def __init__(self, log):
wxTimer.__init__(self)
self.log = log
def Notify(self):
wxBell()
self.log.WriteText('beep!\n')
#---------------------------------------------------------------------------
class TestLayoutConstraints(wxFrame):
def __init__(self, parent):
wxFrame.__init__(self, parent, -1, 'Test Layout Constraints',
wxPyDefaultPosition, wxSize(500, 300))
self.SetAutoLayout(true)
EVT_BUTTON(self, 100, self.OnButton)
self.panelA = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize,
wxSIMPLE_BORDER)
self.panelA.SetBackgroundColour(wxBLUE)
lc = wxLayoutConstraints()
lc.top.SameAs(self, wxTop, 10)
lc.left.SameAs(self, wxLeft, 10)
lc.bottom.SameAs(self, wxBottom, 10)
lc.right.PercentOf(self, wxRight, 50)
self.panelA.SetConstraints(lc)
self.panelB = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize,
wxSIMPLE_BORDER)
self.panelB.SetBackgroundColour(wxRED)
lc = wxLayoutConstraints()
lc.top.SameAs(self, wxTop, 10)
lc.right.SameAs(self, wxRight, 10)
lc.bottom.PercentOf(self, wxBottom, 30)
lc.left.RightOf(self.panelA, 10)
self.panelB.SetConstraints(lc)
self.panelC = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize,
wxSIMPLE_BORDER)
self.panelC.SetBackgroundColour(wxWHITE)
lc = wxLayoutConstraints()
lc.top.Below(self.panelB, 10)
lc.right.SameAs(self, wxRight, 10)
lc.bottom.SameAs(self, wxBottom, 10)
lc.left.RightOf(self.panelA, 10)
self.panelC.SetConstraints(lc)
b = wxButton(self.panelA, 100, ' Panel A ')
lc = wxLayoutConstraints()
lc.centreX.SameAs (self.panelA, wxCentreX)
lc.centreY.SameAs (self.panelA, wxCentreY)
lc.height.AsIs ()
lc.width.PercentOf (self.panelA, wxWidth, 50)
b.SetConstraints(lc);
b = wxButton(self.panelB, 100, ' Panel B ')
lc = wxLayoutConstraints()
lc.top.SameAs (self.panelB, wxTop, 2)
lc.right.SameAs (self.panelB, wxRight, 4)
lc.height.AsIs ()
lc.width.AsIs ()
b.SetConstraints(lc);
self.panelD = wxWindow(self.panelC, -1, wxPyDefaultPosition, wxPyDefaultSize,
wxSIMPLE_BORDER)
self.panelD.SetBackgroundColour(wxGREEN)
wxStaticText(self.panelD, -1, "Panel D", wxPoint(4, 4)).SetBackgroundColour(wxGREEN)
b = wxButton(self.panelC, 100, ' Panel C ')
lc = wxLayoutConstraints()
lc.top.Below (self.panelD)
lc.left.RightOf (self.panelD)
lc.height.AsIs ()
lc.width.AsIs ()
b.SetConstraints(lc);
lc = wxLayoutConstraints()
lc.bottom.PercentOf (self.panelC, wxHeight, 50)
lc.right.PercentOf (self.panelC, wxWidth, 50)
lc.height.SameAs (b, wxHeight)
lc.width.SameAs (b, wxWidth)
self.panelD.SetConstraints(lc);
def OnButton(self, event):
self.Close(true)
def OnCloseWindow(self, event):
self.Destroy()
#---------------------------------------------------------------------------
class TestGrid(wxFrame):
def __init__(self, parent):
wxFrame.__init__(self, parent, -1, 'Test Grid',
wxPyDefaultPosition, wxSize(500, 300))
grid = wxGrid(self, -1)
grid.CreateGrid(16, 16)
grid.SetColumnWidth(3, 200)
grid.SetRowHeight(4, 45)
grid.SetCellValue("First cell", 0, 0)
grid.SetCellValue("Another cell", 1, 1)
grid.SetCellValue("Yet another cell", 2, 2)
grid.SetCellTextFont(wxFont(12, wxROMAN, wxITALIC, wxNORMAL), 0, 0)
grid.SetCellTextColour(wxRED, 1, 1)
grid.SetCellBackgroundColour(wxCYAN, 2, 2)
grid.UpdateDimensions()
grid.AdjustScrollbars()
def OnCloseWindow(self, event):
self.Destroy()
#---------------------------------------------------------------------------
class TestNotebookWindow(wxFrame):
def __init__(self, parent):
wxFrame.__init__(self, parent, -1, 'Test wxNotebook',
wxPyDefaultPosition, wxPyDefaultSize)
nb = wxNotebook(self, -1)
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxBLUE)
nb.AddPage(win, "Blue")
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxRED)
nb.AddPage(win, "Red")
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxGREEN)
nb.AddPage(win, "Green")
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxCYAN)
nb.AddPage(win, "Cyan")
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxWHITE)
nb.AddPage(win, "White")
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxBLACK)
nb.AddPage(win, "Black")
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxNamedColour('MIDNIGHT BLUE'))
nb.AddPage(win, "MIDNIGHT BLUE")
win = wxWindow(nb, -1, wxPyDefaultPosition, wxPyDefaultSize, wxRAISED_BORDER)
win.SetBackgroundColour(wxNamedColour('INDIAN RED'))
nb.AddPage(win, "INDIAN RED")
nb.SetSelection(0)
self.SetSize(wxSize(500, 300)) # force a redraw so the notebook will draw
def OnCloseWindow(self, event):
self.Destroy()
#---------------------------------------------------------------------------
class AppFrame(wxFrame):
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
wxSize(420, 200))
self.icon = wxIcon('bitmaps/mondrian.ico', wxBITMAP_TYPE_ICO)
self.SetIcon(self.icon)
self.mainmenu = wxMenuBar()
menu = wxMenu()
menu.Append(200, 'E&xit', 'Get the heck outta here!')
EVT_MENU(self, 200, self.OnFileExit)
self.mainmenu.Append(menu, '&File')
menu = self.MakeTestsMenu()
self.mainmenu.Append(menu, '&Tests')
self.SetMenuBar(self.mainmenu)
self.log = wxTextCtrl(self, -1, '', wxPyDefaultPosition, wxPyDefaultSize,
wxTE_MULTILINE|wxTE_READONLY)
self.log.WriteText('Test 4:\n')
(w, self.charHeight) = self.log.GetTextExtent('X')
def MakeTestsMenu(self):
menu = wxMenu()
mID = NewId()
menu.Append(mID, '&Simple Controls')
EVT_MENU(self, mID, self.OnTestSimpleControls)
mID = NewId()
menu.Append(mID, '&Timer', '', true)
EVT_MENU(self, mID, self.OnTestTimer)
self.timerID = mID
self.timer = None
mID = NewId()
menu.Append(mID, '&Layout Constraints')
EVT_MENU(self, mID, self.OnTestLayoutConstraints)
mID = NewId()
menu.Append(mID, '&Grid')
EVT_MENU(self, mID, self.OnTestGrid)
smenu = wxMenu() # make a sub-menu
mID = NewId()
smenu.Append(mID, '&Colour')
EVT_MENU(self, mID, self.OnTestColourDlg)
mID = NewId()
smenu.Append(mID, '&Directory')
EVT_MENU(self, mID, self.OnTestDirDlg)
mID = NewId()
smenu.Append(mID, '&File')
EVT_MENU(self, mID, self.OnTestFileDlg)
mID = NewId()
smenu.Append(mID, '&Single Choice')
EVT_MENU(self, mID, self.OnTestSingleChoiceDlg)
mID = NewId()
smenu.Append(mID, '&TextEntry')
EVT_MENU(self, mID, self.OnTestTextEntryDlg)
mID = NewId()
smenu.Append(mID, '&Font')
EVT_MENU(self, mID, self.OnTestFontDlg)
mID = NewId()
smenu.Append(mID, '&PageSetup')
EVT_MENU(self, mID, self.OnTestPageSetupDlg)
mID = NewId()
smenu.Append(mID, '&Print')
EVT_MENU(self, mID, self.OnTestPrintDlg)
mID = NewId()
smenu.Append(mID, '&Message')
EVT_MENU(self, mID, self.OnTestMessageDlg)
menu.AppendMenu(NewId(), '&Common Dialogs', smenu)
mID = NewId()
menu.Append(mID, '&Notebook')
EVT_MENU(self, mID, self.OnTestNotebook)
return menu
def WriteText(self, str):
self.log.WriteText(str)
w, h = self.log.GetClientSize()
numLines = h/self.charHeight
x, y = self.log.PositionToXY(self.log.GetLastPosition())
self.log.ShowPosition(self.log.XYToPosition(x, y-numLines+1))
def OnFileExit(self, event):
self.Close()
def OnCloseWindow(self, event):
self.Destroy()
def OnTestSimpleControls(self, event):
dlg = TestSimpleControlsDlg(self, self)
dlg.SetModal(true)
dlg.Centre()
dlg.Show(true)
dlg.Destroy()
def OnTestTimer(self, event):
if self.timer:
self.mainmenu.Check(self.timerID, false)
self.timer.Stop()
self.timer = None
else:
self.mainmenu.Check(self.timerID, true)
self.timer = TestTimer(self)
self.timer.Start(1000)
def OnTestLayoutConstraints(self, event):
win = TestLayoutConstraints(self)
win.Show(true)
def OnTestGrid(self, event):
win = TestGrid(self)
win.Show(true)
win.SetSize(wxSize(505, 300)) # have to force a resize, or the grid doesn't
# show up for some reason....
def OnTestColourDlg(self, event):
data = wxColourData()
data.SetChooseFull(true)
dlg = wxColourDialog(self, data)
if dlg.ShowModal() == wxID_OK:
data = dlg.GetColourData()
self.log.WriteText('You selected: %s\n' % str(data.GetColour().Get()))
dlg.Destroy()
def OnTestDirDlg(self, event):
dlg = wxDirDialog(self)
if dlg.ShowModal() == wxID_OK:
self.log.WriteText('You selected: %s\n' % dlg.GetPath())
dlg.Destroy()
def OnTestFileDlg(self, event):
dlg = wxFileDialog(self, "Choose a file", ".", "", "*.*", wxOPEN)
if dlg.ShowModal() == wxID_OK:
self.log.WriteText('You selected: %s\n' % dlg.GetPath())
dlg.Destroy()
def OnTestSingleChoiceDlg(self, event):
dlg = wxSingleChoiceDialog(self, 'Test Single Choice', 'The Caption',
['zero', 'one', 'two', 'three', 'four', 'five',
'six', 'seven', 'eight'])
if dlg.ShowModal() == wxID_OK:
self.log.WriteText('You selected: %s\n' % dlg.GetStringSelection())
dlg.Destroy()
def OnTestTextEntryDlg(self, event):
dlg = wxTextEntryDialog(self, 'What is your favorite programming language?',
'Duh??', 'Python')
#dlg.SetValue("Python is the best!") #### this doesn't work?
if dlg.ShowModal() == wxID_OK:
self.log.WriteText('You entered: %s\n' % dlg.GetValue())
dlg.Destroy()
def OnTestFontDlg(self, event):
dlg = wxFontDialog(self)
if dlg.ShowModal() == wxID_OK:
data = dlg.GetFontData()
font = data.GetChosenFont()
self.log.WriteText('You selected: "%s", %d points, color %s\n' %
(font.GetFaceName(), font.GetPointSize(),
data.GetColour().Get()))
dlg.Destroy()
def OnTestPageSetupDlg(self, event):
data = wxPageSetupData()
data.SetMarginTopLeft(wxPoint(50,50))
data.SetMarginBottomRight(wxPoint(50,50))
dlg = wxPageSetupDialog(self, data)
if dlg.ShowModal() == wxID_OK:
data = dlg.GetPageSetupData()
tl = data.GetMarginTopLeft()
br = data.GetMarginBottomRight()
self.log.WriteText('Margins are: %s %s\n' % (str(tl), str(br)))
dlg.Destroy()
def OnTestPrintDlg(self, event):
data = wxPrintData()
data.EnablePrintToFile(true)
data.EnablePageNumbers(true)
data.EnableSelection(true)
dlg = wxPrintDialog(self, data)
if dlg.ShowModal() == wxID_OK:
self.log.WriteText('\n')
dlg.Destroy()
def OnTestMessageDlg(self, event):
dlg = wxMessageDialog(self, 'Hello from Python and wxWindows!',
'A Message Box', wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
def OnTestNotebook(self, event):
win = TestNotebookWindow(self)
win.Show(true)
#---------------------------------------------------------------------------
class MyApp(wxApp):
def OnInit(self):
frame = AppFrame(NULL, -1, "Test 4: (lots of little tests...)")
frame.Show(true)
self.SetTopWindow(frame)
return true
#---------------------------------------------------------------------------
def main():
app = MyApp(0)
app.MainLoop()
def t():
import pdb
pdb.run('main()')
if __name__ == '__main__':
main()
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.1 1998/08/09 08:28:05 RD
# Initial version
#
#