From cf694132f1c28509a9f84377ce8d374bae4177ad Mon Sep 17 00:00:00 2001 From: Robin Dunn Date: Fri, 30 Apr 1999 03:29:54 +0000 Subject: [PATCH] wxPython 2.0b9, first phase (win32) Added gobs of stuff, see wxPython/README.txt for details git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2310 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- utils/wxPython/.cvsignore | 8 +- utils/wxPython/README.txt | 53 + utils/wxPython/SWIG.patches/SWIG.patch | 11 + utils/wxPython/demo/.cvsignore | 5 + utils/wxPython/demo/ColorPanel.py | 25 + utils/wxPython/demo/DialogUnits.py | 123 + utils/wxPython/demo/Layoutf.py | 62 + utils/wxPython/demo/Main.py | 319 + utils/wxPython/demo/README.txt | 7 + utils/wxPython/demo/SlashDot.py | 378 + utils/wxPython/demo/bitmaps/copy.bmp | Bin 0 -> 238 bytes utils/wxPython/demo/bitmaps/image.bmp | Bin 0 -> 57138 bytes utils/wxPython/demo/bitmaps/image.gif | Bin 0 -> 7116 bytes utils/wxPython/demo/bitmaps/image.jpg | Bin 0 -> 8087 bytes utils/wxPython/demo/bitmaps/image.png | Bin 0 -> 17905 bytes utils/wxPython/demo/bitmaps/mondrian.ico | Bin 0 -> 766 bytes utils/wxPython/demo/bitmaps/new.bmp | Bin 0 -> 238 bytes utils/wxPython/demo/bitmaps/open.bmp | Bin 0 -> 238 bytes utils/wxPython/demo/bitmaps/paste.bmp | Bin 0 -> 238 bytes utils/wxPython/demo/bitmaps/smiles.bmp | Bin 0 -> 246 bytes utils/wxPython/demo/bitmaps/smiles.ico | Bin 0 -> 766 bytes utils/wxPython/demo/bitmaps/test2.bmp | Bin 0 -> 12342 bytes utils/wxPython/demo/bitmaps/tog1.bmp | Bin 0 -> 238 bytes utils/wxPython/demo/bitmaps/tog2.bmp | Bin 0 -> 238 bytes utils/wxPython/demo/demo.py | 4 + utils/wxPython/demo/hangman.py | 463 + utils/wxPython/demo/pyTree.py | 211 + utils/wxPython/demo/wxButton.py | 47 + utils/wxPython/demo/wxCheckBox.py | 80 + utils/wxPython/demo/wxCheckListBox.py | 53 + utils/wxPython/demo/wxChoice.py | 76 + utils/wxPython/demo/wxColourDialog.py | 38 + utils/wxPython/demo/wxComboBox.py | 79 + utils/wxPython/demo/wxDialog.py | 33 + utils/wxPython/demo/wxDirDialog.py | 53 + utils/wxPython/demo/wxFileDialog.py | 62 + utils/wxPython/demo/wxFontDialog.py | 39 + utils/wxPython/demo/wxFrame.py | 41 + utils/wxPython/demo/wxGLCanvas.py | 153 + utils/wxPython/demo/wxGauge.py | 55 + utils/wxPython/demo/wxGrid.py | 77 + utils/wxPython/demo/wxImage.py | 40 + utils/wxPython/demo/wxLayoutConstraints.py | 142 + utils/wxPython/demo/wxListBox.py | 99 + utils/wxPython/demo/wxListCtrl.py | 106 + utils/wxPython/demo/wxMessageDialog.py | 62 + utils/wxPython/demo/wxMiniFrame.py | 42 + utils/wxPython/demo/wxMultipleChoiceDialog.py | 27 + utils/wxPython/demo/wxNotebook.py | 84 + utils/wxPython/demo/wxPageSetupDialog.py | 33 + utils/wxPython/demo/wxPlotCanvas.py | 39 + utils/wxPython/demo/wxPrintDialog.py | 31 + utils/wxPython/demo/wxRadioBox.py | 76 + utils/wxPython/demo/wxSashWindow.py | 152 + .../wxPython/demo/wxScrolledMessageDialog.py | 24 + utils/wxPython/demo/wxScrolledWindow.py | 122 + utils/wxPython/demo/wxSingleChoiceDialog.py | 59 + utils/wxPython/demo/wxSlider.py | 41 + utils/wxPython/demo/wxSpinButton.py | 49 + utils/wxPython/demo/wxSplitterWindow.py | 67 + utils/wxPython/demo/wxStaticBitmap.py | 41 + utils/wxPython/demo/wxStaticText.py | 73 + utils/wxPython/demo/wxStatusBar.py | 114 + utils/wxPython/demo/wxTextCtrl.py | 40 + utils/wxPython/demo/wxTextEntryDialog.py | 50 + utils/wxPython/demo/wxTimer.py | 67 + utils/wxPython/demo/wxToolBar.py | 125 + utils/wxPython/demo/wxTreeCtrl.py | 98 + utils/wxPython/distrib/SelfInst-README.txt | 52 + utils/wxPython/distrib/wxPython.rsp | 8 +- utils/wxPython/distrib/wxPython.wse | 184 +- utils/wxPython/distrib/wxPython.wsm | Bin 939 -> 5796 bytes utils/wxPython/distrib/zipit.bat | 3 +- utils/wxPython/lib/.cvsignore | 1 + utils/wxPython/lib/__init__.py | 3 + utils/wxPython/lib/dialogs.py | 106 + utils/wxPython/lib/layoutf.py | 262 + utils/wxPython/lib/wxPlotCanvas.py | 468 + utils/wxPython/src/.cvsignore | 2 + utils/wxPython/src/Makefile.pre.in | 8 +- utils/wxPython/src/Setup.in | 53 +- utils/wxPython/src/Setup.in.linux | 14 +- utils/wxPython/src/_defs.i | 118 +- utils/wxPython/src/_extras.py | 73 +- utils/wxPython/src/cmndlgs.i | 54 +- utils/wxPython/src/controls.i | 31 +- utils/wxPython/src/controls2.i | 97 +- utils/wxPython/src/events.i | 25 +- utils/wxPython/src/gdi.i | 102 +- utils/wxPython/src/glcanvas.i | 1093 ++ utils/wxPython/src/glcanvasc.def | 2 + utils/wxPython/src/helpers.cpp | 112 +- utils/wxPython/src/helpers.h | 49 +- utils/wxPython/src/image.i | 152 + utils/wxPython/src/makefile.vc | 194 +- utils/wxPython/src/misc.i | 20 +- utils/wxPython/src/msw/cmndlgs.cpp | 2041 ++-- utils/wxPython/src/msw/cmndlgs.py | 199 +- utils/wxPython/src/msw/controls.cpp | 1476 ++- utils/wxPython/src/msw/controls.py | 6 + utils/wxPython/src/msw/controls2.cpp | 1586 ++- utils/wxPython/src/msw/controls2.py | 31 +- utils/wxPython/src/msw/events.cpp | 919 +- utils/wxPython/src/msw/events.py | 23 + utils/wxPython/src/msw/frames.cpp | 185 +- utils/wxPython/src/msw/gdi.cpp | 1502 ++- utils/wxPython/src/msw/glcanvas.cpp | 9770 +++++++++++++++++ utils/wxPython/src/msw/glcanvas.py | 1423 +++ utils/wxPython/src/msw/image.cpp | 1588 +++ utils/wxPython/src/msw/image.py | 226 + utils/wxPython/src/msw/mdi.cpp | 126 +- utils/wxPython/src/msw/misc.cpp | 1255 ++- utils/wxPython/src/msw/misc.py | 6 + utils/wxPython/src/msw/stattool.cpp | 575 +- utils/wxPython/src/msw/utils.cpp | 324 +- utils/wxPython/src/msw/utils.py | 6 - utils/wxPython/src/msw/windows.cpp | 1789 ++- utils/wxPython/src/msw/windows.py | 63 +- utils/wxPython/src/msw/windows2.cpp | 1163 +- utils/wxPython/src/msw/windows2.py | 7 + utils/wxPython/src/msw/windows3.cpp | 428 +- utils/wxPython/src/msw/windows3.py | 7 + utils/wxPython/src/msw/wx.cpp | 287 +- utils/wxPython/src/msw/wx.py | 154 +- utils/wxPython/src/my_typemaps.i | 34 +- utils/wxPython/src/utils.i | 21 +- utils/wxPython/src/windows.i | 47 +- utils/wxPython/src/windows2.i | 22 +- utils/wxPython/src/windows3.i | 6 + utils/wxPython/src/wx.i | 112 +- utils/wxPython/src/wxc.def | 4 + utils/wxPython/tests/test1.py | 1 + utils/wxPython/tests/test2.py | 21 +- utils/wxPython/tests/test3.py | 5 +- utils/wxPython/tests/test4.py | 27 +- utils/wxPython/tests/test4s.py | 18 - utils/wxPython/tests/test8.py | 85 + 137 files changed, 31032 insertions(+), 4280 deletions(-) create mode 100644 utils/wxPython/demo/.cvsignore create mode 100644 utils/wxPython/demo/ColorPanel.py create mode 100644 utils/wxPython/demo/DialogUnits.py create mode 100644 utils/wxPython/demo/Layoutf.py create mode 100644 utils/wxPython/demo/Main.py create mode 100644 utils/wxPython/demo/README.txt create mode 100644 utils/wxPython/demo/SlashDot.py create mode 100644 utils/wxPython/demo/bitmaps/copy.bmp create mode 100644 utils/wxPython/demo/bitmaps/image.bmp create mode 100644 utils/wxPython/demo/bitmaps/image.gif create mode 100644 utils/wxPython/demo/bitmaps/image.jpg create mode 100644 utils/wxPython/demo/bitmaps/image.png create mode 100644 utils/wxPython/demo/bitmaps/mondrian.ico create mode 100644 utils/wxPython/demo/bitmaps/new.bmp create mode 100644 utils/wxPython/demo/bitmaps/open.bmp create mode 100644 utils/wxPython/demo/bitmaps/paste.bmp create mode 100644 utils/wxPython/demo/bitmaps/smiles.bmp create mode 100644 utils/wxPython/demo/bitmaps/smiles.ico create mode 100644 utils/wxPython/demo/bitmaps/test2.bmp create mode 100644 utils/wxPython/demo/bitmaps/tog1.bmp create mode 100644 utils/wxPython/demo/bitmaps/tog2.bmp create mode 100755 utils/wxPython/demo/demo.py create mode 100644 utils/wxPython/demo/hangman.py create mode 100644 utils/wxPython/demo/pyTree.py create mode 100644 utils/wxPython/demo/wxButton.py create mode 100644 utils/wxPython/demo/wxCheckBox.py create mode 100644 utils/wxPython/demo/wxCheckListBox.py create mode 100644 utils/wxPython/demo/wxChoice.py create mode 100644 utils/wxPython/demo/wxColourDialog.py create mode 100644 utils/wxPython/demo/wxComboBox.py create mode 100644 utils/wxPython/demo/wxDialog.py create mode 100644 utils/wxPython/demo/wxDirDialog.py create mode 100644 utils/wxPython/demo/wxFileDialog.py create mode 100644 utils/wxPython/demo/wxFontDialog.py create mode 100644 utils/wxPython/demo/wxFrame.py create mode 100644 utils/wxPython/demo/wxGLCanvas.py create mode 100644 utils/wxPython/demo/wxGauge.py create mode 100644 utils/wxPython/demo/wxGrid.py create mode 100644 utils/wxPython/demo/wxImage.py create mode 100644 utils/wxPython/demo/wxLayoutConstraints.py create mode 100644 utils/wxPython/demo/wxListBox.py create mode 100644 utils/wxPython/demo/wxListCtrl.py create mode 100644 utils/wxPython/demo/wxMessageDialog.py create mode 100644 utils/wxPython/demo/wxMiniFrame.py create mode 100644 utils/wxPython/demo/wxMultipleChoiceDialog.py create mode 100644 utils/wxPython/demo/wxNotebook.py create mode 100644 utils/wxPython/demo/wxPageSetupDialog.py create mode 100644 utils/wxPython/demo/wxPlotCanvas.py create mode 100644 utils/wxPython/demo/wxPrintDialog.py create mode 100644 utils/wxPython/demo/wxRadioBox.py create mode 100644 utils/wxPython/demo/wxSashWindow.py create mode 100644 utils/wxPython/demo/wxScrolledMessageDialog.py create mode 100644 utils/wxPython/demo/wxScrolledWindow.py create mode 100644 utils/wxPython/demo/wxSingleChoiceDialog.py create mode 100644 utils/wxPython/demo/wxSlider.py create mode 100644 utils/wxPython/demo/wxSpinButton.py create mode 100644 utils/wxPython/demo/wxSplitterWindow.py create mode 100644 utils/wxPython/demo/wxStaticBitmap.py create mode 100644 utils/wxPython/demo/wxStaticText.py create mode 100644 utils/wxPython/demo/wxStatusBar.py create mode 100644 utils/wxPython/demo/wxTextCtrl.py create mode 100644 utils/wxPython/demo/wxTextEntryDialog.py create mode 100644 utils/wxPython/demo/wxTimer.py create mode 100644 utils/wxPython/demo/wxToolBar.py create mode 100644 utils/wxPython/demo/wxTreeCtrl.py create mode 100644 utils/wxPython/lib/.cvsignore create mode 100644 utils/wxPython/lib/__init__.py create mode 100644 utils/wxPython/lib/dialogs.py create mode 100644 utils/wxPython/lib/layoutf.py create mode 100644 utils/wxPython/lib/wxPlotCanvas.py create mode 100644 utils/wxPython/src/glcanvas.i create mode 100644 utils/wxPython/src/glcanvasc.def create mode 100644 utils/wxPython/src/image.i create mode 100644 utils/wxPython/src/msw/glcanvas.cpp create mode 100644 utils/wxPython/src/msw/glcanvas.py create mode 100644 utils/wxPython/src/msw/image.cpp create mode 100644 utils/wxPython/src/msw/image.py delete mode 100644 utils/wxPython/tests/test4s.py create mode 100644 utils/wxPython/tests/test8.py diff --git a/utils/wxPython/.cvsignore b/utils/wxPython/.cvsignore index 4194213098..0c4536c4ea 100644 --- a/utils/wxPython/.cvsignore +++ b/utils/wxPython/.cvsignore @@ -1,4 +1,3 @@ -docs *.zip .cvsignore .emacs.desktop @@ -26,6 +25,7 @@ controls2.pyc controls2.pyc controls2.pyo controls2.pyo +docs events.py events.py events.pyc @@ -44,6 +44,10 @@ gdi.pyc gdi.pyc gdi.pyo gdi.pyo +glcanvas.py +glcanvas.pyc +image.py +image.pyc mdi.py mdi.py mdi.pyc @@ -67,6 +71,8 @@ utils.py utils.pyc utils.pyc utils.pyo +utilsc.ilk +utilsc.pyd windows.py windows.py windows.pyc diff --git a/utils/wxPython/README.txt b/utils/wxPython/README.txt index 84de32ebda..027c4f70e1 100644 --- a/utils/wxPython/README.txt +++ b/utils/wxPython/README.txt @@ -59,6 +59,59 @@ Or you can send mail directly to the list using this address: +What's new in 2.0b9 +------------------- +Bug fix for ListCtrl in test4.py (Was a missing file... DSM!) + +Bug fix for occassional GPF on Win32 systems upon termination of a +wxPython application. + +Added wxListBox.GetSelections returning selections as a Tuple. + +Added a wxTreeItemData that is able to hold any Python object and be +associated with items in a wxTreeCtrl. Added test pytree.py to show +this feature off. + +Added wxSafeYield function. + +OpenGL Canvas can be optionally compiled in to wxPython. + +Awesome new Demo Framework for showing off wxPython and for learning +how it all works. + +The pre-built Win32 version is no longer distributing the wxWindows +DLL. It is statically linked with the wxWindows library instead. + +Added a couple missing items from the docs. + +Added wxImage, wxImageHandler, wxPNGHandler, wxJPEGHandler, +wxGIFHandler and wxBMPHandler. + + + +What's new in 2.0b8 +------------------- +Support for using Python threads in wxPython apps. + +Several missing methods from various classes. + +Various bug fixes. + + + +What's new in 2.0b7 +------------------- +Added DLG_PNT and DLG_SZE convienience methods to wxWindow class. + +Added missing constructor and other methods for wxMenuItem. + + + +What's new in 2.0b6 +------------------- +Just a quickie update to fix the self-installer to be compatible with +Python 1.5.2b2's Registry settings. + What's new in 2.0b5 ------------------- diff --git a/utils/wxPython/SWIG.patches/SWIG.patch b/utils/wxPython/SWIG.patches/SWIG.patch index 539916bc5f..6eb496c61e 100644 --- a/utils/wxPython/SWIG.patches/SWIG.patch +++ b/utils/wxPython/SWIG.patches/SWIG.patch @@ -370,6 +370,17 @@ + * + * -- Revision History + * $Log$ ++ * Revision 1.2 1999/04/30 03:28:35 RD ++ * wxPython 2.0b9, first phase (win32) ++ * Added gobs of stuff, see wxPython/README.txt for details ++ * ++ * Revision 1.1.4.1 1999/03/27 23:28:59 RD ++ * ++ * wxPython 2.0b8 ++ * Python thread support ++ * various minor additions ++ * various minor fixes ++ * + * Revision 1.1 1998/10/03 05:56:03 RD + * *** empty log message *** + * diff --git a/utils/wxPython/demo/.cvsignore b/utils/wxPython/demo/.cvsignore new file mode 100644 index 0000000000..a0a19f67a4 --- /dev/null +++ b/utils/wxPython/demo/.cvsignore @@ -0,0 +1,5 @@ +*.pyc +.emacs.desktop +hangman_dict.txt +setup.bat +tmphtml.txt diff --git a/utils/wxPython/demo/ColorPanel.py b/utils/wxPython/demo/ColorPanel.py new file mode 100644 index 0000000000..42332ac9ec --- /dev/null +++ b/utils/wxPython/demo/ColorPanel.py @@ -0,0 +1,25 @@ +#!/bin/env python +#---------------------------------------------------------------------------- +# Name: ColorPanel.py +# Purpose: Testing lots of stuff, controls, window types, etc. +# +# Author: Robin Dunn & Gary Dumer +# +# Created: +# RCS-ID: $Id$ +# Copyright: (c) 1998 by Total Control Software +# Licence: wxWindows license +#---------------------------------------------------------------------------- + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + + +class ColoredPanel(wxWindow): + def __init__(self, parent, color): + wxWindow.__init__(self, parent, -1, + wxDefaultPosition, wxDefaultSize, wxRAISED_BORDER) + self.SetBackgroundColour(color) + +#--------------------------------------------------------------------------- \ No newline at end of file diff --git a/utils/wxPython/demo/DialogUnits.py b/utils/wxPython/demo/DialogUnits.py new file mode 100644 index 0000000000..403488c2c1 --- /dev/null +++ b/utils/wxPython/demo/DialogUnits.py @@ -0,0 +1,123 @@ +#!/bin/env python +#---------------------------------------------------------------------------- +# Name: DialogUnits.py +# Purpose: A minimal wxPython program that is a bit smarter than test1. +# +# Author: Robin Dunn +# +# Created: A long time ago, in a galaxy far, far away... +# RCS-ID: $Id$ +# Copyright: (c) 1998 by Total Control Software +# Licence: wxWindows license +#---------------------------------------------------------------------------- + + +## import all of the wxPython GUI package +from wxPython.wx import * + + +#--------------------------------------------------------------------------- + +## Create a new frame class, derived from the wxPython Frame. +class MyFrame(wxFrame): + + def __init__(self, parent, id, title): + # First, call the base class' __init__ method to create the frame + wxFrame.__init__(self, parent, id, title, + wxPoint(100, 100), wxSize(160, 100)) + + # Associate some events with methods of this class + EVT_SIZE(self, self.OnSize) + EVT_MOVE(self, self.OnMove) + + # Add a panel and some controls to display the size and position + panel = wxPanel(self, -1) + wxStaticText(panel, -1, "Size:", + wxDLG_PNT(panel, wxPoint(4, 4)), wxDefaultSize) + wxStaticText(panel, -1, "Pos:", + wxDLG_PNT(panel, wxPoint(4, 14)), wxDefaultSize) + self.sizeCtrl = wxTextCtrl(panel, -1, "", + wxDLG_PNT(panel, wxPoint(24, 4)), + wxDLG_SZE(panel, wxSize(36, -1)), + wxTE_READONLY) + + self.posCtrl = wxTextCtrl(panel, -1, "", + wxDLG_PNT(panel, wxPoint(24, 14)), + wxDLG_SZE(panel, wxSize(36, -1)), + wxTE_READONLY) + + + # This method is called automatically when the CLOSE event is + # sent to this window + def OnCloseWindow(self, event): + # tell the window to kill itself + self.Destroy() + + + # This method is called by the System when the window is resized, + # because of the association above. + def OnSize(self, event): + size = event.GetSize() + self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height)) + + # tell the event system to continue looking for an event handler, + # so the default handler will get called. + event.Skip() + + # This method is called by the System when the window is moved, + # because of the association above. + def OnMove(self, event): + pos = event.GetPosition() + self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y)) + + + +#--------------------------------------------------------------------------- +# if running standalone + +if __name__ == "__main__": + # Every wxWindows application must have a class derived from wxApp + class MyApp(wxApp): + + # wxWindows calls this method to initialize the application + def OnInit(self): + + # Create an instance of our customized Frame class + frame = MyFrame(NULL, -1, "This is a test") + frame.Show(true) + + # Tell wxWindows that this is our main window + self.SetTopWindow(frame) + + # Return a success flag + return true + + + app = MyApp(0) # Create an instance of the application class + app.MainLoop() # Tell it to start processing events + + +#--------------------------------------------------------------------------- +# if running as part of the Demo Framework... + +def runTest(frame, nb, log): + win = MyFrame(frame, -1, "This is a test") + frame.otherWin = win + win.Show(true) + + +overview = """\ +A simple example that shows how to use Dialog Units. +""" + +#---------------------------------------------------------------------------- +# + + + + + + + + + diff --git a/utils/wxPython/demo/Layoutf.py b/utils/wxPython/demo/Layoutf.py new file mode 100644 index 0000000000..e5809b60c5 --- /dev/null +++ b/utils/wxPython/demo/Layoutf.py @@ -0,0 +1,62 @@ + +from wxPython.wx import * +from wxPython.lib.layoutf import Layoutf + +#--------------------------------------------------------------------------- + +class TestLayoutf(wxPanel): + def __init__(self, parent): + wxPanel.__init__(self, parent, -1) + + self.SetAutoLayout(true) + EVT_BUTTON(self, 100, self.OnButton) + + self.panelA = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelA.SetBackgroundColour(wxBLUE) + self.panelA.SetConstraints(Layoutf('t=t10#1;l=l10#1;b=b10#1;r%r50#1',(self,))) + + self.panelB = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelB.SetBackgroundColour(wxRED) + self.panelB.SetConstraints(Layoutf('t=t10#1;r=r10#1;b%b30#1;l>10#2', (self,self.panelA))) + + self.panelC = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelC.SetBackgroundColour(wxWHITE) + self.panelC.SetConstraints(Layoutf('t_10#3;r=r10#1;b=b10#1;l>10#2', (self,self.panelA,self.panelB))) + + b = wxButton(self.panelA, 100, ' Panel A ') + b.SetConstraints(Layoutf('X=X#1;Y=Y#1;h*;w%w50#1', (self.panelA,))) + + b = wxButton(self.panelB, 100, ' Panel B ') + b.SetConstraints(Layoutf('t=t2#1;r=r4#1;h*;w*', (self.panelB,))) + + self.panelD = wxWindow(self.panelC, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelD.SetBackgroundColour(wxGREEN) + self.panelD.SetConstraints(Layoutf('b%h50#1;r%w50#1;h=h#2;w=w#2', (self.panelC, b))) + + b = wxButton(self.panelC, 100, ' Panel C ') + b.SetConstraints(Layoutf('t_#1;l>#1;h*;w*', (self.panelD,))) + + wxStaticText(self.panelD, -1, "Panel D", wxPoint(4, 4)).SetBackgroundColour(wxGREEN) + + def OnButton(self, event): + wxBell() + + + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestLayoutf(nb) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + +overview = Layoutf.__doc__ diff --git a/utils/wxPython/demo/Main.py b/utils/wxPython/demo/Main.py new file mode 100644 index 0000000000..a17ff06e0f --- /dev/null +++ b/utils/wxPython/demo/Main.py @@ -0,0 +1,319 @@ +#!/bin/env python +#---------------------------------------------------------------------------- +# Name: Main.py +# Purpose: Testing lots of stuff, controls, window types, etc. +# +# Author: Robin Dunn & Gary Dumer +# +# Created: +# RCS-ID: $Id$ +# Copyright: (c) 1999 by Total Control Software +# Licence: wxWindows license +#---------------------------------------------------------------------------- + +import sys, os +from wxPython.wx import * + + +#--------------------------------------------------------------------------- + + +_treeList = [ + ('Managed Windows', ['wxFrame', 'wxDialog', 'wxMiniFrame']), + + ('Miscellaneous Windows', ['wxGrid', 'wxSashWindow', + 'wxScrolledWindow', 'wxSplitterWindow', + 'wxStatusBar', 'wxToolBar', 'wxNotebook']), + + ('Common Dialogs', ['wxColourDialog', 'wxDirDialog', 'wxFileDialog', + 'wxSingleChoiceDialog', 'wxTextEntryDialog', + 'wxFontDialog', 'wxPageSetupDialog', 'wxPrintDialog', + 'wxMessageDialog']), + + ('Controls', ['wxButton', 'wxCheckBox', 'wxCheckListBox', 'wxChoice', + 'wxComboBox', 'wxGauge', 'wxListBox', 'wxListCtrl', 'wxTextCtrl', + 'wxTreeCtrl', 'wxSpinButton', 'wxStaticText', 'wxStaticBitmap', + 'wxRadioBox', 'wxSlider']), + + ('Window Layout', ['wxLayoutConstraints']), + + ('Micellaneous', ['wxTimer', 'wxGLCanvas', 'DialogUnits', 'wxImage']), + + ('wxPython Library', ['Layoutf', 'wxScrolledMessageDialog', + 'wxMultipleChoiceDialog', 'wxPlotCanvas']), + + ('Cool Contribs', ['pyTree', 'hangman', 'SlashDot']), + + ] + +#--------------------------------------------------------------------------- + +class wxPythonDemo(wxFrame): + def __init__(self, parent, id, title): + wxFrame.__init__(self, parent, -1, title, + wxDefaultPosition, wxSize(700, 550)) + if wxPlatform == '__WXMSW__': + self.icon = wxIcon('bitmaps/mondrian.ico', wxBITMAP_TYPE_ICO) + self.SetIcon(self.icon) + + self.otherWin = None + EVT_IDLE(self, self.OnIdle) + + self.Centre(wxBOTH) + self.CreateStatusBar(1, wxST_SIZEGRIP) + splitter = wxSplitterWindow(self, -1) + splitter2 = wxSplitterWindow(splitter, -1) + + # Prevent TreeCtrl from displaying all items after destruction + self.dying = false + + # Make a File menu + self.mainmenu = wxMenuBar() + menu = wxMenu() + mID = NewId() + menu.Append(mID, 'E&xit', 'Get the heck outta here!') + EVT_MENU(self, mID, self.OnFileExit) + self.mainmenu.Append(menu, '&File') + + # Make a Help menu + mID = NewId() + menu = wxMenu() + menu.Append(mID, '&About', 'wxPython RULES!!!') + EVT_MENU(self, mID, self.OnHelpAbout) + self.mainmenu.Append(menu, '&Help') + self.SetMenuBar(self.mainmenu) + + # Create a TreeCtrl + tID = NewId() + self.tree = wxTreeCtrl(splitter, tID) + root = self.tree.AddRoot("Overview") + for item in _treeList: + child = self.tree.AppendItem(root, item[0]) + for childItem in item[1]: + self.tree.AppendItem(child, childItem) + self.tree.Expand(root) + EVT_TREE_ITEM_EXPANDED (self.tree, tID, self.OnItemExpanded) + EVT_TREE_ITEM_COLLAPSED (self.tree, tID, self.OnItemCollapsed) + EVT_TREE_SEL_CHANGED (self.tree, tID, self.OnSelChanged) + + + # Create a Notebook + self.nb = wxNotebook(splitter2, -1) + + # Set up a TextCtrl on the Overview Notebook page + self.ovr = wxTextCtrl(self.nb, -1, '', wxDefaultPosition, wxDefaultSize, + wxTE_MULTILINE|wxTE_READONLY) + self.nb.AddPage(self.ovr, "Overview") + + + # Set up a TextCtrl on the Demo Code Notebook page + self.txt = wxTextCtrl(self.nb, -1, '', wxDefaultPosition, wxDefaultSize, + wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL) + self.nb.AddPage(self.txt, "Demo Code") + + + # select initial items + self.nb.SetSelection(0) + self.tree.SelectItem(root) + + # Set up a log on the View Log Notebook page + self.log = wxTextCtrl(splitter2, -1, '', wxDefaultPosition, wxDefaultSize, + wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL) + (w, self.charHeight) = self.log.GetTextExtent('X') + self.WriteText('wxPython Demo Log:\n') + + + # add the windows to the splitter and split it. + splitter.SplitVertically(self.tree, splitter2) + splitter.SetSashPosition(180, true) + splitter.SetMinimumPaneSize(20) + + splitter2.SplitHorizontally(self.nb, self.log) + splitter2.SetSashPosition(360, true) + splitter2.SetMinimumPaneSize(20) + + # make our log window be stdout + sys.stdout = self + + #--------------------------------------------- + def WriteText(self, text): + self.log.WriteText(text) + if wxPlatform == '__WXMSW__': + w, h = self.log.GetClientSizeTuple() + numLines = h/self.charHeight + x, y = self.log.PositionToXY(self.log.GetLastPosition()) + self.log.ShowPosition(self.log.XYToPosition(x, y-numLines+1)) + + def write(self, txt): + self.WriteText(txt) + + #--------------------------------------------- + def OnItemExpanded(self, event): + item = event.GetItem() + self.log.WriteText("OnItemExpanded: %s\n" % self.tree.GetItemText(item)) + + #--------------------------------------------- + def OnItemCollapsed(self, event): + item = event.GetItem() + self.log.WriteText("OnItemCollapsed: %s\n" % self.tree.GetItemText(item)) + + #--------------------------------------------- + def OnSelChanged(self, event): + if self.dying: + return + + if self.nb.GetPageCount() == 3: + if self.nb.GetSelection() == 2: + self.nb.SetSelection(0) + self.nb.DeletePage(2) + + item = event.GetItem() + itemText = self.tree.GetItemText(item) + + if itemText == 'Overview': + self.GetDemoFile('Main.py') + self.SetOverview('Overview', overview) + #self.nb.ResizeChildren(); + self.nb.Refresh(); + #wxYield() + + else: + if os.path.exists(itemText + '.py'): + self.GetDemoFile(itemText + '.py') + module = __import__(itemText, globals()) + self.SetOverview(itemText, module.overview) + + # in case runTest is modal, make sure things look right... + self.nb.Refresh(); + wxYield() + + window = module.runTest(self, self.nb, self) + if window: + self.nb.AddPage(window, 'Demo') + self.nb.SetSelection(2) + self.nb.ResizeChildren(); + + else: + self.ovr.Clear() + self.txt.Clear() + + + #--------------------------------------------- + # Get the Demo files + def GetDemoFile(self, filename): + self.txt.Clear() + if not self.txt.LoadFile(filename): + self.txt.WriteText("Cannot open %s file." % filename) + + self.txt.SetInsertionPoint(0) + self.txt.ShowPosition(0) + + #--------------------------------------------- + def SetOverview(self, name, text): + self.ovr.Clear() + self.ovr.WriteText(text) + self.nb.SetPageText(0, name) + self.ovr.SetInsertionPoint(0) + self.ovr.ShowPosition(0) + + #--------------------------------------------- + # Menu methods + def OnFileExit(self, event): + self.Close() + + + def OnHelpAbout(self, event): + about = wxMessageDialog(self, + "wxPython is a Python extension module that\n" + "encapsulates the wxWindows GUI classes.\n\n" + "This demo shows off some of the capabilities\n" + "of wxPython.\n\n" + " Developed by Robin Dunn", + "About wxPython", wxOK) + about.ShowModal() + about.Destroy() + + + #--------------------------------------------- + def OnCloseWindow(self, event): + self.dying = true + self.Destroy() + + #--------------------------------------------- + def OnIdle(self, event): + if self.otherWin: + self.otherWin.Raise() + self.otherWin = None + + +#--------------------------------------------------------------------------- +#--------------------------------------------------------------------------- + +class MyApp(wxApp): + def OnInit(self): + wxImage_AddHandler(wxJPEGHandler()) + wxImage_AddHandler(wxPNGHandler()) + wxImage_AddHandler(wxGIFHandler()) + frame = wxPythonDemo(NULL, -1, "wxPython: (A Demonstration)") + frame.Show(true) + self.SetTopWindow(frame) + return true + +#--------------------------------------------------------------------------- + +def main(): + app = MyApp(0) + app.MainLoop() + + +#--------------------------------------------------------------------------- + + + +overview = """\ +Python +------------ + +Python is an interpreted, interactive, object-oriented programming language often compared to Tcl, Perl, Scheme, or Java. + +Python combines remarkable power with very clear syntax. It has modules, classes, exceptions, very high level dynamic data types, and dynamic typing. There are interfaces to many system calls and libraries, and new built-in modules are easily written in C or C++. Python is also usable as an extension language for applications that need a programmable interface. + +wxWindows +-------------------- + +wxWindows is a free C++ framework designed to make cross-platform programming child's play. Well, almost. wxWindows 2 supports Windows 3.1/95/98/NT, Unix with GTK/Motif/Lesstif, with a Mac version underway. Other ports are under consideration. + +wxWindows is a set of libraries that allows C++ applications to compile and run on several different types of computers, with minimal source code changes. There is one library per supported GUI (such as Motif, or Windows). As well as providing a common API (Application Programming Interface) for GUI functionality, it provides functionality for accessing some commonly-used operating system facilities, such as copying or deleting files. wxWindows is a 'framework' in the sense that it provides a lot of built-in functionality, which the application can use or replace as required, thus saving a great deal of coding effort. Basic data structures such as strings, linked lists and hash tables are also supported. + +wxPython +---------------- + +wxPython is a Python extension module that encapsulates the wxWindows GUI classes. Currently it is only available for the Win32 and GTK ports of wxWindows, but as soon as the other ports are brought up to the same level as Win32 and GTK, it should be fairly trivial to enable wxPython to be used with the new GUI. + +The wxPython extension module attempts to mirror the class heiarchy of wxWindows as closely as possible. 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. Unfortunately, because of differences in the languages, wxPython doesn't match wxWindows exactly, but the differences should be easy to absorb because they are natural to Python. For example, some methods that return multiple values via argument pointers in C++ will return a tuple of values in Python. + +There is still much to be done for wxPython, many classes still need to be mirrored. Also, wxWindows is still somewhat of a moving target so it is a bit of an effort just keeping wxPython up to date. On the other hand, there are enough of the core classes completed that useful applications can be written. + +wxPython is close enough to the C++ version that the majority of the wxPython documentation is actually just notes attached to the C++ documents that describe the places where wxPython is different. There is also a series of sample programs included, and a series of documentation pages that assist the programmer in getting started with wxPython. +""" + + + + + + + +#---------------------------------------------------------------------------- +#---------------------------------------------------------------------------- + +if __name__ == '__main__': + main() + +#---------------------------------------------------------------------------- + + + + + + + diff --git a/utils/wxPython/demo/README.txt b/utils/wxPython/demo/README.txt new file mode 100644 index 0000000000..c1f635e957 --- /dev/null +++ b/utils/wxPython/demo/README.txt @@ -0,0 +1,7 @@ +To run the main demo in this directory, execute demo.py. In other +words, one of the following commands should do it: + + demo.py + python demo.py + pythonw demo.py + diff --git a/utils/wxPython/demo/SlashDot.py b/utils/wxPython/demo/SlashDot.py new file mode 100644 index 0000000000..8a8fda8bc6 --- /dev/null +++ b/utils/wxPython/demo/SlashDot.py @@ -0,0 +1,378 @@ +#!/usr/bin/python +"""This is SlashDot 1.2 + + It's the obligatory Slashdot.org headlines reader that +any modern widget set/library must have in order to be taken +seriously :-) + + Usage is quite simple; wxSlash attempts to download the +'ultramode.txt' file from http://slashdot.org, which +contains the headlines in a computer friendly format. It +then displays said headlines in a wxWindows list control. + + You can read articles using either Python's html library +or an external browser. Uncheck the 'browser->internal' menu +item to use the latter option. Use the settings dialog box +to set which external browser is started. + + This code is available under the wxWindows license, see +elsewhere. If you modify this code, be aware of the fact +that slashdot.org's maintainer, CmdrTaco, explicitly asks +'ultramode.txt' downloaders not to do this automatically +more than twice per hour. If this feature is abused, +CmdrTaco may remove the ultramode file completely and that +will make a *lot* of people unhappy. + + I want to thank Alex Shnitman whose slashes.pl +(Perl/GTK) script gave me the idea for this applet. + + Have fun with it, + + Harm van der Heijden (H.v.d.Heijden@phys.tue.nl) +""" + +from wxPython.wx import * +from httplib import HTTP +from htmllib import HTMLParser +import os +import re +import formatter + +class HTMLTextView(wxFrame): + def __init__(self, parent, id, title='HTMLTextView', url=None): + wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition, + wxSize(600,400)) + + self.mainmenu = wxMenuBar() + + menu = wxMenu() + menu.Append(201, '&Open URL...', 'Open URL') + EVT_MENU(self, 201, self.OnFileOpen) + menu.Append(209, 'E&xit', 'Exit viewer') + EVT_MENU(self, 209, self.OnFileExit) + + self.mainmenu.Append(menu, '&File') + self.SetMenuBar(self.mainmenu) + self.CreateStatusBar(1) + + self.text = wxTextCtrl(self, -1, "", wxPyDefaultPosition, + wxPyDefaultSize, wxTE_MULTILINE | wxTE_READONLY) + + if (url): + self.OpenURL(url) + + def logprint(self, x): + self.SetStatusText(x) + + def OpenURL(self, url): + self.url = url + m = re.match('file:(\S+)\s*', url) + if m: + f = open(m.groups()[0],'r') + else: + m = re.match('http://([^/]+)(/\S*)\s*', url) + if m: + host = m.groups()[0] + path = m.groups()[1] + else: + m = re.match('http://(\S+)\s*', url) + if not m: + # Invalid URL + self.logprint("Invalid or unsupported URL: %s" % (url)) + return + host = m.groups()[0] + path = '' + f = RetrieveAsFile(host,path,self.logprint) + if not f: + self.logprint("Could not open %s" % (url)) + return + self.logprint("Receiving data...") + data = f.read() + tmp = open('tmphtml.txt','w') + fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp)) + p = HTMLParser(fmt) + self.logprint("Parsing data...") + p.feed(data) + p.close() + tmp.close() + tmp = open('tmphtml.txt', 'r') + self.text.SetValue(tmp.read()) + self.SetTitle(url) + self.logprint(url) + + def OnFileOpen(self, event): + dlg = wxTextEntryDialog(self, "Enter URL to open:", "") + if dlg.ShowModal() == wxID_OK: + url = dlg.GetValue() + else: + url = None + if url: + self.OpenURL(url) + + def OnFileExit(self, event): + self.Close() + + def OnCloseWindow(self, event): + self.Destroy() + + +def ParseSlashdot(f): + art_sep = re.compile('%%\r?\n') + line_sep = re.compile('\r?\n') + data = f.read() + list = art_sep.split(data) + art_list = [] + for i in range(1,len(list)-1): + art_list.append(line_sep.split(list[i])) + return art_list + +def myprint(x): + print x + +def RetrieveAsFile(host, path='', logprint = myprint): + try: + h = HTTP(host) + except: + logprint("Failed to create HTTP connection to %s... is the network available?" % (host)) + return None + h.putrequest('GET',path) + h.putheader('Accept','text/html') + h.putheader('Accept','text/plain') + h.endheaders() + errcode, errmsg, headers = h.getreply() + if errcode != 200: + logprint("HTTP error code %d: %s" % (errcode, errmsg)) + return None + f = h.getfile() +# f = open('/home/harm/ultramode.txt','r') + return f + + +class AppStatusBar(wxStatusBar): + def __init__(self, parent): + wxStatusBar.__init__(self,parent, -1) + self.SetFieldsCount(2) + self.SetStatusWidths([-1, 100]) + self.but = wxButton(self, 1001, "Refresh") + EVT_BUTTON(self, 1001, parent.OnViewRefresh) + self.OnSize(None) + + def logprint(self,x): + self.SetStatusText(x,0) + + def OnSize(self, event): + rect = self.GetFieldRect(1) + self.but.SetPosition(wxPoint(rect.x+2, rect.y+2)) + self.but.SetSize(wxSize(rect.width-4, rect.height-4)) + +# This is a simple timer class to start a function after a short delay; +class QuickTimer(wxTimer): + def __init__(self, func, wait=100): + wxTimer.__init__(self) + self.callback = func + self.Start(wait); # wait .1 second (.001 second doesn't work. why?) + def Notify(self): + self.Stop(); + apply(self.callback, ()); + +class AppFrame(wxFrame): + def __init__(self, parent, id, title): + wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition, + wxSize(650, 250)) + + # if the window manager closes the window: + EVT_CLOSE(self, self.OnCloseWindow); + + # Now Create the menu bar and items + self.mainmenu = wxMenuBar() + + menu = wxMenu() + menu.Append(209, 'E&xit', 'Enough of this already!') + EVT_MENU(self, 209, self.OnFileExit) + self.mainmenu.Append(menu, '&File') + menu = wxMenu() + menu.Append(210, '&Refresh', 'Refresh headlines') + EVT_MENU(self, 210, self.OnViewRefresh) + menu.Append(211, '&Slashdot Index', 'View Slashdot index') + EVT_MENU(self, 211, self.OnViewIndex) + menu.Append(212, 'Selected &Article', 'View selected article') + EVT_MENU(self, 212, self.OnViewArticle) + self.mainmenu.Append(menu, '&View') + menu = wxMenu() + menu.Append(220, '&Internal', 'Use internal text browser',TRUE) + menu.Check(220, true) + self.UseInternal = 1; + EVT_MENU(self, 220, self.OnBrowserInternal) + menu.Append(222, '&Settings...', 'External browser Settings') + EVT_MENU(self, 222, self.OnBrowserSettings) + self.mainmenu.Append(menu, '&Browser') + menu = wxMenu() + menu.Append(230, '&About', 'Some documentation'); + EVT_MENU(self, 230, self.OnAbout) + self.mainmenu.Append(menu, '&Help') + + self.SetMenuBar(self.mainmenu) + + if wxPlatform == '__WXGTK__': + # I like lynx. Also Netscape 4.5 doesn't react to my cmdline opts + self.BrowserSettings = "xterm -e lynx %s &" + elif wxPlatform == '__WXMSW__': + # netscape 4.x likes to hang out here... + self.BrowserSettings = '\\progra~1\\Netscape\\Communicator\\Program\\netscape.exe %s' + else: + # a wild guess... + self.BrowserSettings = 'netscape %s' + + # A status bar to tell people what's happening + self.sb = AppStatusBar(self) + self.SetStatusBar(self.sb) + + self.list = wxListCtrl(self, 1100) + self.list.SetSingleStyle(wxLC_REPORT) + self.list.InsertColumn(0, 'Subject') + self.list.InsertColumn(1, 'Date') + self.list.InsertColumn(2, 'Posted by') + self.list.InsertColumn(3, 'Comments') + self.list.SetColumnWidth(0, 300) + self.list.SetColumnWidth(1, 150) + self.list.SetColumnWidth(2, 100) + self.list.SetColumnWidth(3, 100) + + EVT_LIST_ITEM_SELECTED(self, 1100, self.OnItemSelected) + EVT_LEFT_DCLICK(self.list, self.OnLeftDClick) + + self.logprint("Connecting to slashdot... Please wait.") + # wxYield doesn't yet work here. That's why we use a timer + # to make sure that we see some GUI stuff before the slashdot + # file is transfered. + self.timer = QuickTimer(self.DoRefresh, 1000) + + def logprint(self, x): + self.sb.logprint(x) + + def OnFileExit(self, event): + self.Destroy() + + def DoRefresh(self): + f = RetrieveAsFile('slashdot.org','/ultramode.txt',self.sb.logprint) + art_list = ParseSlashdot(f) + self.list.DeleteAllItems() + self.url = [] + self.current = -1 + i = 0; + for article in art_list: + self.list.InsertStringItem(i, article[0]) + self.list.SetStringItem(i, 1, article[2]) + self.list.SetStringItem(i, 2, article[3]) + self.list.SetStringItem(i, 3, article[6]) + self.url.append(article[1]) + i = i + 1 + self.logprint("File retrieved OK.") + + def OnViewRefresh(self, event): + self.logprint("Connecting to slashdot... Please wait."); + wxYield() + self.DoRefresh() + + def DoViewIndex(self): + if self.UseInternal: + self.view = HTMLTextView(self, -1, 'slashdot.org', + 'http://slashdot.org') + self.view.Show(true) + else: + self.logprint(self.BrowserSettings % ('http://slashdot.org')) + #os.system(self.BrowserSettings % ('http://slashdot.org')) + wxExecute(self.BrowserSettings % ('http://slashdot.org')) + self.logprint("OK") + + def OnViewIndex(self, event): + self.logprint("Starting browser... Please wait.") + wxYield() + self.DoViewIndex() + + def DoViewArticle(self): + if self.current<0: return + url = self.url[self.current] + if self.UseInternal: + self.view = HTMLTextView(self, -1, url, url) + self.view.Show(true) + else: + self.logprint(self.BrowserSettings % (url)) + os.system(self.BrowserSettings % (url)) + self.logprint("OK") + + def OnViewArticle(self, event): + self.logprint("Starting browser... Please wait.") + wxYield() + self.DoViewArticle() + + def OnBrowserInternal(self, event): + if self.mainmenu.Checked(220): + self.UseInternal = 1 + else: + self.UseInternal = 0 + + def OnBrowserSettings(self, event): + dlg = wxTextEntryDialog(self, "Enter command to view URL.\nUse %s as a placeholder for the URL.", "", self.BrowserSettings); + if dlg.ShowModal() == wxID_OK: + self.BrowserSettings = dlg.GetValue() + + def OnAbout(self, event): + dlg = wxMessageDialog(self, __doc__, "wxSlash", wxOK | wxICON_INFORMATION) + dlg.ShowModal() + + def OnItemSelected(self, event): + self.current = event.m_itemIndex + self.logprint("URL: %s" % (self.url[self.current])) + + def OnLeftDClick(self, event): + (x,y) = event.Position(); + # Actually, we should convert x,y to logical coords using + # a dc, but only for a wxScrolledWindow widget. + # Now wxGTK derives wxListCtrl from wxScrolledWindow, + # and wxMSW from wxControl... So that doesn't work. + #dc = wxClientDC(self.list) + ##self.list.PrepareDC(dc) + #x = dc.DeviceToLogicalX( event.GetX() ) + #y = dc.DeviceToLogicalY( event.GetY() ) + id = self.list.HitTest(wxPoint(x,y)) + #print "Double click at %d %d" % (x,y), id + # Okay, we got a double click. Let's assume it's the current selection + wxYield() + self.OnViewArticle(event) + + def OnCloseWindow(self, event): + self.Destroy() + + +#--------------------------------------------------------------------------- +# if running standalone + +if __name__ == '__main__': + class MyApp(wxApp): + def OnInit(self): + frame = AppFrame(NULL, -1, "Slashdot Breaking News") + frame.Show(true) + self.SetTopWindow(frame) + return true + + app = MyApp(0) + app.MainLoop() + + + +#--------------------------------------------------------------------------- +# if running as part of the Demo Framework... + +def runTest(frame, nb, log): + win = AppFrame(NULL, -1, "Slashdot Breaking News") + frame.otherWin = win + win.Show(true) + + +overview = __doc__ + + +#---------------------------------------------------------------------------- + + diff --git a/utils/wxPython/demo/bitmaps/copy.bmp b/utils/wxPython/demo/bitmaps/copy.bmp new file mode 100644 index 0000000000000000000000000000000000000000..4551a06bfa79e0a42c1ffb7cdbb90fd4f699dce2 GIT binary patch literal 238 zcmZvVK?*`K3`9pLxU9$U91{2|@hV+>tjiv)Cz3AyzP{vxy7<$~OeTT!c7JQf6T89- z%?kmn<${;(P#uFN<0A#FuUo(qgT{&F@ekspii W=d@ZzPG(Cb=QBs}_=7thzxV(viB<;y literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/image.bmp b/utils/wxPython/demo/bitmaps/image.bmp new file mode 100644 index 0000000000000000000000000000000000000000..bbab4cd3b08d22098ef8419a56eb3d3fd1a28c4f GIT binary patch literal 57138 zcmeIb2Y4OVdFMS~rzlY(DUp;|KoY(8-h1!8cU;^K;G#Ez015WqtJqYiLN&{FymnmT z*iP}LJIN-oMv-q?a_loUY@5I^OiPODfCwfPY z+J_HX2lrWKt~;i$^iN;zXTRq~$IK1K-j@dEUL82_#vnJd3>ew$W2S+$eCLk3n6n0xNnZ7con?6V5#P@HYLVW>@qHve zKMo`3oB%l^Ffw}FK62PLbifMdg9`x=Cq`y(4eWh+VE=1_2i_cl=}f&n=Dr@=u+cGN z;aBh;0AW9VQeb50%$f0clz8+7b>=N)x0{nlIKH*Rot;-!~hcu)Wq1VGN5Q2^WZI@G&&uYLD!+r)%oY!C#*0N0-P-oskMPGi64-FNwh3oIie#@=3GaY?PA zNCP;0uYS&ckzUmmi{p#XUI;&f5%a)+d2o=u(Qb!-T)YH2rY`ic37DMe#j_YaW*<2u z%q9gBm5Cle}9kN4wqtd^-Y<%Uj1rdRv1EP0azLihpSNs zLLG|nOf_;Qh6)su_kyFh*hBi6Ao%jhUBtuR#PVMGCB>Y{|n zc?pw~I!tiSaX|LHqWd6+-Wfi4cZff+yXb%G_&A)|W3yp&*+z_xJr=YH00A$YMGFYY zFAXghMqGO20gN~f9)!Jn_w0fB)yVR5VPd`a9tY?Yln#ms;GmVbKwxTmS~UQoKo)iy zUk)5Q##zuo!xrh)dr}I(#qmXeKc1fjMkXd;CsYYst$I)GMLbG5=9fiO3djg;B4L7W zP6&%V2HWBHhB-!|?71c`RfMbh8cqPEZF>UFckQljh2M!l{zxc|z#Q5Yfb?~1S~7YQ$kpZ8b{M!QI8 zf)q9&!#Co48RcH2cX50d!p~p?23GzxscMnDBkn58Kj=W^ECUmqVpvOXm(2#}V|VFJ z@$|I%{^32KAcDmAfQ4gp3Y$QR#WLR>(__oB)`g@z8%R+w;kScx0vf&@XZA?8w|vhL_o=D zWho&8Oz!EC?rxa;K8)XUbBUSQLX1tQOmG z5{?gI1c2Pbh*Bahj9lrzr$pWyB8iEuC1Y+%h3QFuj7c3JX7eJw%8FhbU)Xjb{46j6 zGfz%pey9o%ff0hPM~~u(D5rx1Wxt^jU~+6N;gS$p#ny6$Wap!VTZzj?N0lXp>bZvz zmEE)3X&W2AQdXAGAWn=3J#t34B%D=BVvW|!rkmulMF^t z7$Yzuogt+}7U^9aU)W=T{46lya8T)iL#_0P%5e*r96wI#jSaDbxg|^{oRQ&Sm6%id z1rRA#)EQEiwFrO=4RKF}AhZTQ6fluWM4W7v6E|-P zm|VF+*&zlS3I$i4J*Yt`2+l`?khz|nMNNxf*O4PCe~o_u?;)aLdoB~k*w~nGSez9g z!nm^8Tqc&dSY9t4inlIPlbBd8D+_?&XmECZPz$`^vr|iq&rV#6jSHxUA-|7tC5mBW zuAgt%P$ir-^mH4o!d1s@$9Wg#76F7sdKbs{qwq5rfy0e5NK5G~aV>!qS$Ru=R?S<(jl?$$)%3tehqQ74hdkhT$CEcl)7*RoH;iump(SnEhi1fV-Y6(9b z6N@6Ti+VVhv$_FBo!AjkDkj|aS>d(=6E-eDWuQdJ`0MHZm-Iq1RXK+GaK(OIQQt*+ z7svM_@w3n)7$K5-MTsDDF{m?q^;LlvrgF&H9Q+A4D)oWx!1Mwd#D~!@XdF(VILt#s z=HX$njf_~v#xS&0e3-Kz^y!kHsf)c+=f&(2Rbn?kmdg*p$jC99+N;WKJ^Twy_L#ZB z>`RWhI|By@WW7Di!OTs^p6ia8oBjJQDBrPJloW%KHF%l`>_IgLWUiGnRoF3-_75-M{x0 z$J`r^{cjF(Fmt0HdS`DtFfw_B5D3FP_6dkJvH#WS9hUSO3APLl>Kg++GGd16$w`}& zUKe!_9MIsY3qhVJI9sCSj~^*#na<5M8&#Wp$$MjoK+qy9-__$Zd>=;(0q#$)a?|0nAB zkr%7ms(U_gnL5R@=AU(4&zEh^PkVd2>zYSCW#M0{HawD2*D0RGhllfA^=ST7XBYmU zM_%coj@v$Pf10Eo;cA9!6!_+mcU#Dp>TZ&t4)suHr;2}F)TyUGd_&jI)s-J~*~344 z%s1SV`=}*8Ec(^Wpo)+--rUz=%*8H*Tnkbi5CA#L(%}{9Lz=3|R13@+RHg zz@So@LHPjMKvU_l=H}+c#>R$*2KGb8jbmr6LSkH!a~0)uMKK}kYCqSH9%Vqw;PPer*|ThYr%v${sCMi%4Ii}* z95mTyyUe>gjH7MF!S)wvE2>%J@q!jorF6L4mZKaj?Mgg;=_p zk)=!P>+7L{XH`~KR>)7!?k3}Ovw5b)wzs|SK>CQsbn@a=cs?TnF0yiNm@1j`s)x2)utmydS++4M@PE{ z2MrEKcV8b!9DeDg{!5o^r%zjt9<>}kY&(3o52pZ+;M6G^wh(?+eg426j9_9hI<#4@ zOTTmpBZ|xJbFoQh5T0_nFWGlr>7(Doc1=!u zzwY4rfqf?X?k>}KyJ4ugy|2zV+19_mXXJ!s@~oWgE&)PgMsC~~c=1Kc*|Qx74;qgi zH6Jj^zQB%IAF2v>F646YySw^ljY9`4n2wA-NMWNJl|X=Arsp#sQ%n|<6+vp|vbbQc zW#q73%7pHY!N%I|vht>)!iv0tl3YHm`}TDmK5RL0!hZCq3Cm|-ps};FvaYVWu8y`j zu3v|3fC)CUipB_}eAxJ6Ny3eEH2|SY%gO{5JS!(BCrf^+jfJ(AVhC&rA^_=qvlaeFLXXF`eO&^zvNCta!0gGlIL`10Qd?49d&>^C~*%>8>!eN!g<4wwyT&@weu-P>E(++0vy zod?gAm&1ECwKc%mc>H+h;ls_-)AUK*z(B*`VEgXfW-4-z9pkqKnYJd!@fdz~G4}ie zfswb~5*We!Adod*&H#{kQ?BO!%5}`6=@yy?tI(NgX=$mcsb!tHh|un-di%k4`fcKp zZ5oW+aNuykX}wcDhJn^*Q*A{{ab9IcReN!3Z=HFnec*tJyA6Pmix&Z`YC zW4Uc@#Rfw~PY?ZpY(z9U4)t`6HB=jlN?LMqtI}bc(#HIf+I)DU#9+v8ZcZsFiA+ok zkBJEj508$HN=S;&$WG7C&+nuN6XWFCwP6;NAjGX0#wAxDORozfunp`7rRsx#?VPCV z7^{U<>a4}!BBwSbsW3XVBrc;uFjY=zdP#kLZAW>Vt==@&j&vP5WJO3~lhBP=0zxLR ziiMn^&sd=55D`k1a{;Pn_?X2$*U>pzU(u1DR+NyC86A}v7M&QuC$qM;u&u4Kr>Cx` zr?RQ3w7fh!Co3r>F(oZIB_*Y1Xb3HACBQ<7(Sqp(APOT$B>EgOp&~RiG$bS>NPc3o z!xQo%lM13U$`f+yQp>yZn)=JTChKem+mIpF@hNt`9__#~tm`f>sLd*A$}MZn zhePV@_Kw}Vt<3tldUXP>yK@JCI4)c;@88eh!bKPct&SST*D%>+ooz=r^zSn{W=*#7 z9$?!wJ6mP77Bn>p0hp1Ikd%~}m040=TwaB2sA%7}uVwGv>cPRn?r!8{QAbCO-QGGr zZrr;UF75ibMd@G!3C5tPBs=`c=%{Lz4+RJ#23zu@secSNfia&cUtA&Sv}~0|Ntt<9wsigA?*2i`%o>$E)p!+r}?jcE8v=drQRYFdhuUEsdtC z+{%ool(5vo`24zzT2o2aD0I}@_U^^cf_u#<&9SkZ#>P-ILQ+yhLIT_fOuEMFhfWzf zCaR0uGgFFVL*oO2WBdXmeWQ}XqN1Xb3JQ|)^1|ceef<3yQ@;Sez+nHtkbuBo+7+19 z(o$-*HjIvT?%9J1#xPbv?1j*)h((kkT~SFfF)_$h9>Hysi=wk@l8Rb0^PAFg>XIQm zG|@jIB`_*IgtN%}nAC{GteE`jtU6Hwg_+|L<3b}s zynH-8JUw>p+7(+|oY~Y=H#}@Tas+#W2Mv)IK6h>*^db-tSx5sYg^C?JcDTE{Z{NP1 zytoG)aCrvyezfq>F1Xi87ZO=~bzcJwz|r#j7(9j3{)*8ZA`&VuZ!l-P{$ z;NalMPjc~wNNM%zpm zH>5pH{r$L^DS3IJ5fOfVex81w!4W~R2{EbZDL|}ccD8+PuDGWsp|CI_H8mhQIx;N{ zq!c47Dp9jduphnpQ9ob=!v=LvzhN7TwBYH}9DL|~y!*W4`r|sgM0kzH!`|o-xRm~+ z1L?iUw4mIEltxFXXBR6Ga^AjFlk7De~`bgpDzM1uB0Tjy1KBVquOTcpj3uZ z0dhSbMsKsBIrL;`i=l-+QJySrh%!I8r&q9-Z>2|IhfjLU|E zA`?R+lR}UN1@#$q=2F8%L;skgDk3%x#H>MUe zrxi4(qd;-NVzXm6++3GsO6?e^H;gx#rdv8k>zey23L7)xvmC~Kv>MUwYjvoggWC=eMBiZI`?aSITgU{re@ECOIilIe6_(ysLM0-Oi-B@ML@0_gZ zKi(O>FHn0^3$_R2vD)``b&oexbmk`)#w6xP#b$-2mc}6@{Tlq-Zn}96`?t;x;oLR! z^<`I9hQ`MFhlFg-*sQ&+t?gM`Fp)NP#b}(Xudx+mRVN1L`>i&w(uOtHwrptG&UUYu z#JGsah|utmz~BI1KOYZIPb6VbQc`GYYEp4=9{ttZD|8m7-2&)+@|#bt7+Mi&i)=PE zqw!Jem<=fU=PI9b8+3C$nuCoa8`9133~pLkTyjwif-yWH7?uu<@`*|bf!Knkj5>RX zd0)%;d8_cwW@glkdzt}YQ7hzXNnNS=Xt8~<%SV^F?!Rn!=~nymF*V^aY2mS{5n*9r zsYOL;HAQY;bzA0Gwyk_?U_^koub2Cd?K^kw^ziUVC@sxtZmu5~upT&IKX5?Jm3utB z9mbAab8bLyzy`;LCBsWxkLJK_$Zd7&>aA&8Q%Ymem{q3yMn_5ecvZ`A1v;+UTu{=U zh3ME|T<3PkZD;@Xy5SP@Y%|dtJW~wsgxp9ZzfVw5ctS#AK4Fc<8jGc>ySuEpIXNpU zFenIsprm{wJbc1;1;luTB=|;WhG5HKQSY#C)2?Z2``4ygi}Gt~64KK#q`iH-cY5r6 zrtul=iniADbX<8H{-*Kp;W99in+rO2VjqTt1V%?^5Zf#%L5zQFj9?D~4Wia!up~_Q z^FuMxY3f|@uPd}Wf;qSLZ7uC6MY>`R!4>Ecxp`xRly+v(ht`9wC7;gHexlLs%}1&n zM+}y|E%o-2?Am0mK`trFHpCF3{V#FDWy8yZ2V={Po$1BJ!I6;|PTSMAi&MwM*>S4EklimHl;DFtN)xxMSA-F)!T(73~}CAl;v zAx~)4u=v2B7(c&ouh4{mn5;0g4D4ju+eE|!NoH>)J zT|mvtZJrR|{_b7dQi|eXNX+|?xmfK_H0_{h#tO@d&8eG(wD8)1*oUVo4x)upceQ+;a^%#jSMVWz(KNSkGUvtdttV}BX(3JeLKVGlKk%ZHam zPlOou)msm=)L4rUgY<@PP*5;ol+@I;l9Iy4#=PokoXp7BSQs9~N6Y=AJp*IC!&3ud zvO}?2F{iUDQ#SwFM(wZlR&6qG4bP4f81WVu*=~`Hu}5>;Y3q&x+URK+uhq!Ibj>uX-3H;#(NGjJYV z9`R}M2shL*^a{Bh6vQ~6blSt@KTL1(+Zo~!pU|Ja+Oax1 zFWR@wSNoBCG^bvc+ov?`_cZPIHSJYxrFEr8iU*Pt>eT47=QunZ?&uM?IY47W8qwAh7dK%{%GKnf= zW@ZxbLD7Rp*PS0Ym``urWVfL7Z#3U;U^+9!ovge1D|VsZjEWp>Ymk4RX?>U zV$-&5+ZZ5*n?c9);u<_$sCfGGPisHcv{&?dE*)69sd$r@j~D9FKg@s0PnT%_sGq`$ z@NDypj*AWm2w>2;fNsaUf!PQVtA3bI?|goKpj%vjf)S)Bu@1h$DG@&qZ&G%M|dpd6zSnq=n_6?=ic0BXBwc^xY z=x0|9Er;2*zxRUplI`c3c0|+0v=vvDZ@u~a^Y3jGU3WoSVP3I4Z0nAl?)3jI1}KPt zOnO#L4fay+i4((@FE51N^1bEyQ=AR+uJsPh4PElHCHnVLjB97Lbr;rczrA(MA3Ool z0rJN3=X`@ay#hQue0TZ%s0bD5}D;2-(w zHwW_I0vH0)uW3Stz=40KEjzt5Zz6T+*OzL4sc9^B?rhtpd{5KZ;6@}BPduir7+jHLNU}_~lh3X0F3GJ-k4=m8 z4fcBe)FyEUfaYwH=ZJfGcTQGKVoXkGRAx|Evj1k|v#ztQgC|?p_$7D|en~4xEUe8= zPfu?gEUC2?KJ$lbF+#K--n$_`aSwC%^79Cf4SDA4Pm9MPot%#gZBGJXevy%W(a~%v zm6cV!y&bI5#w?E$Cn!khwpb8Q$PGU93?KMeOuic*pU>p#7>wX2k{01l5vad$g9s#% zE;bHavv(gT*(EGY4SeTZuTTv%k3n=cZ*%iz)CaNxj3{xDUz=ImQ)U=x4*lIgaq&fQ z@y=oQy6#G(Ty}MGR9Y|q@sILC!*2NUGvXRHdBd$u&-;dYcm?j<Ob@eOhD z`jT}3#M5tAV3;30lUtuklol^BXZ@J!yde(KNG2#g>Goot5xg~R3PvnxD0bmuj9y}@_&3p_2s z#H)ki;{)U3{9|I0D=J8~Hcw5Nj~=xhJJx&jXlq*=8W6QY5JnhaOi1kQ1t2(s06|n< zso5NIUO5;+O(={Ictog@!=gGxuK^~@bNe=tVSXrb?y|m}JBS;Ojd8=L|7pG6Jk+sl z|I?OdA|fNvm0$$(2~#SkGQGO9q;sIL=*?_#u~RL2^zT3e5-`L{CxnQPADtDl?T!0@ z@Qh)tPpF4y;Er8>?%vJP(B%$)=HA zZue5Yt0qp0d11H3gctGB3JDV`RZt~KUy0Sb7pHIX`Ht=miWY`Xm?;1=jJ8DX4sm-8`229stM1w_#3|ulAXWO7dxz{&7zvK|U;0xiwEw5G zD;hS2Ck6#X_#(SPq5`+qZ(Z(K{#4(S;^u6~z+cy$S^jj-+8IK>kwqvh%&D)}F>>wN zlq>@IPACw&Bx&5&kRGsVVAa}NYnKhkFcjhu&lfh3Em>oF zBAN_O1}1q-xgoE4sJ!=B+w3cS``;9kUntRGiA!oe>12>HA0}v%oG+v<`{gq2OWIRo zPo`K?+K<)M?ki83h<|oyy@3BU$!TBJAH?G}CT;{H;Smv81qImO-ON)sbcnPFH(%iR zc8}VZ{!;cc94_0xYH&3!WmHOvH`X%=_lSs?I0iZSg#RO=4%mTE{EMYHc{TPT(5xg&M-g`J6_8RQtMAg~(4S0GAFgDc_%m zoF6)7rZi>w_m*i4IvBa4-|d-(wRkT0?1U~8GUJ#0o73o(&ss6G5){Ye=7y!E1#nba znoj`DZU-ineSIY+6RuN6US4)VL4HX|WkW-Y$z)(^`GEtfqr{p&a%oT|q@!HGh?p=X z3nQs~6Dzu_W!Poykaz=vb4hkwb)X@pOORQZo#j_}F}YuB(mBW3pL9rcQ6lb^a#88j zw8F%a#=JIr9c38n{z2MBKhi1HPHJ2GHzyL<$O#Qg@lVK)@Vc}^^ad~?q$61|Fxe+C z+K0GMWJ>VUf8sQiWmi09dwOvgh$4)tC47jOHEv%9VX9 z5;9{*xbvwr<~0wO^&W4XdBr|+OB4X_mP;q`?g_Lr(&x&$m3> z{=tnFY`2ATA-HpuD^u?a$0OVs|p(wea!X{N1fOv6K3p z(_72QYxo2Q`-g=E;Y!EGB5Zt)`-sc_MZack`%^waUb}pD;F1JK2CVt3HTq3tcfGKC zWB2abtf54=&%22>1B(AHf*T^z@=1vl{`{6SsJQ1#+Om;l1w93W`&nn9)9w3iI#(Rl zpY?3{df}4q+7S{Kl9-gZ?i=g$XU*srL}y1QmX=24X)c*oCJ&xJkB6dy{7qyFhdkjIp z=Rd#S#PL<_8Qa?E;*hZ907B?HZf+I9qMu6TEBiLE%!hPjXktKIPQ(kJkB+Qd3K-s+bgDA{xouYPsyd!pAq_ca!w{zoC;BW6r`x z^$892V+#ohi;j+qkKc7_mvFm&CdHBLfgMTPJ$!crg!zWYhj^dy)Ng`HmEx{tx^nx? zEh6lIaflClUF!PF!bM$vd701buG~GTc{kHMzA62Sx3yJ6t2(BedL}#cKmpF+gx;P_ z1<#5oeF_;zDs|W)8-GT3`no5BYcS-iO9-Irk1Ip0gJ1|YAv={h?T`shnAks zmR3|$*w9eVay|R^_g}bxhk{5UV~7tzIE!iNV8k_HP}OGRfMB>1&caEdLR(m0@4N#> zNS)}*q#Qm>I-awFsos2DWJ%O`Ny$%dcy#$o>bt`_lTzf-X*}q~(;kL-!kS9O8hKP-TiPOLiGXxM1NiL2d$>{rrr_QKOotsb* z8(SXj_H#EeQeTmx^|v(bJI;U%p%q5tQ`&aJ_Qd4mgw)jdw6v7m+$@O^s;v93UL9m@ zZK~8hjNYNk=iPoL0~8p>k{`DBd83bBc-vi!AU%Lc|DKeD0Q0XUMj+(t+UmWlQyUX9 zOHwk6lfei!dGkn_abJVu7+u;kbl5UDCl=Lb>M=b`n2UMGOt@1p!R`VnY#d;cF$&Bs zEWcP1@wu>7-(Dp`zC7!%^!CsyuUt>cQ7CA{(PKJ5D|0Scqk~0kzJC&w% zskpPBBZ{gyf@OG^UI76lt)i3S*Sx<*Nd6z(6KI=iH+lzp;FUzDgs0aeE&Itb(KCOq zw=npopHL!b5N^w0feu2EQ`&0#s))iM()4X3)wccZ? zOerdg%gl^ON{Y?MNGdF(0J52+#)%VDsr7>qS-40|0y+hZU_{Z4^uKaIuv&3X01>ts z)|4pqmvePRB3P!|IN*C>+_D1vJMV1$6Q^GOqTalX))%6al03Y<$!=qDMJ0!26erhp zmD#4cI!-s}wEQ=5G2%UUB6;PHRtW1hHwU4MZE zt9>;P0qP~Z&zm#(FkF}M5xx(*rK9$zu zvZjKZ^0e&IREd$i`u^gs$y(dKc2WL4XX@WW?YCG`j}Z}XsQ@NUZGzneG{h!f^+I$} zEXV5TX&-A|{@!w-(GUVo$+@C`MM_3Wc7AqIX(2PBnp#>qO(ubnk3PQEn}>AIk=~Z$ zvU%7Y9`lci^2XDoN-ZM%*@@?bH}N}Cv0l(G+t9HNLn}NknBwI8s>~gq*r5-%youXc zH|?u3Nc$(62J7t;0Kpgt&G$u2*%-RgS!RQ+KtaX-k7+2mc5u56_`(%buxCO>VeIxG>Id%*gl3iU*+9o(QHkdlG z`1n+UXw)R{-%rgd@nJ9`wzFs9c`zcTW6L+-sP`QJ3Q;&jg$A`fXU-sCfddHAfphva zYDh#8Z`~pS2CO3AiPZZ6DJq+{dSFdlS{gABoLRt5kEP_sQv+`vZ|~h>cXw$hGtP`*{94#8)oXfM|Xyf`LFxh(;}RUns7$>d<f_HRi*Xy70t~Q z@YpY1qD~$Yl;Xz6&|7`P9JDt+@{5^*Az@2&glzee;icuK9!ifkeR_-D1OH2)-u(}@ z#m_~TOyoXsdv(f4JoVwtmTD%sQ1?qsQP*@$&rCh@P5KXYQvl42GbZMXx%T5GI+m3y zSl~sdlGg`?Z}O6GPxS5OfihdA$(t}{+&UC_jRZc0qymGi49z1dr;HzgKE<~61?^b_uD8$D+NAjpK-R~(za z`Melweu&F+zaH@^6$x1n&t3TJiOC5$x!F(s&3(S=(!r&rz4m8*{Wl^~VcAuK)&lmielceo@3tEmbGp`^AwzT%;Cl<))xTmKFb{eUsvkp_m7QD3lZB~um}73EhSxbi!z#GQ9*?ibt>3<>$B{Iy?R zs~y*fB?g)UtLv*t2b14tPfMuSLaVC8D{;}s^gxNJL`3^vmG(1!oi*PU`~^ zn-}Yu>M3F=XEg1c6jSJH82&e;)r4@v*vs$|(p|cuR9ukc-S8(H#C?dvFx*Hs0EH5n z(eJs!vdTX)B041{EjJelrZ_}3j1)u7fyO1jTp|P}X2$&(@yHZ43_Od#sjB7J{#j=v z&Dr1>>gBS7*G;Tj`cF%RMLH)W*k;q_+?HIb0*K2IiWflh@PJXtR*=&t-o+_KN+eC3 zTmeSJbm^nweT9Tp2+kwERL<8rWMo6Li>0LH0&XI=A}4b(A!zu@6{>U1v$Gx3gMtvn z+mh|+jez<%AIcKY%l`i4aiX)cnflZ?I0#51Z%G}>^%J6_)|u9+a+Iy!Ti1Nf842Mm z`a<5V;7Iz|Im^%)W6W#uD}OQ%M+8HLwGGw{r0p0E=nYGV@Op2@(qAmmKCS;&_z3W} zywB5)r;Uf3`wtkHN8dYZ=$kVR9konew6n4ba+`5^485k$9N+o30XmJY5g*nPJF=;V zi7zU`B@7=+UHcswT~VEY!v&)Eh^JGi6KRSBl6;U7DtpB!7_3&YSh4gql(G==^QH{{ zUh8K*-~()&HI?<`51$lO8E7>6hn66aG3jZ^-l(BtCKd-^KXTGSD1af}EnlnjF~%3~ zKL0CiI=wtXQWV%25uO~s{=)iIe>`uPXw2s{(cxFMjn=IsNhzkJ{)5QB;@SeQpp&<@ZZ6&046nnvwqcQ1zr6T;S4QEY&X<);60r zQ?Y;qKpBw~piVnyI(f@qNjm|TnVbAndbP-|3C;hsH?#l5Qe6i{C~1N8A{NLK5um90 zjP2PUZq^@--!ZIZ^pqnii7|o^w%pdHpu6!RBag@Q=kmEU01JFVa~pN5G1klGe$sAj5B^N>J)wkHKBPT2wE?h;C79%^kj0xR=G6(EhNk)otQR44lT zlgP_2$zT1?G8XqWsSX$jr*XKcw#5_1uq<==RXW z+$g5fL{d$i8r+Q$(5G(?YvL z$p%u|hc+Q{MJYZ7s7$Y}eY3>7vZjhs_Ck&-;kk_zto<-xz>KUT@-pbm+iWT zk#k~+l8;9(ro!rN1gg{#jA0zWap8>&ZcU()M&vZX99E9Viio z(`f}^x&(c~S=@rWLW#)h**{ydo?7U{yeMW#u#ybcFL77W6D~5lji1ZJE?rH002glCi`CS@nx6CJ8a)-|Mw)6)i;X2djI3iEYkGT;{QcwwaJ}X062J)PVDSw$4iGyG5PF~Hi5J{B#CA`Q7>z6h zYOvc`UBq_bLi3(IWmaouLxb0eFdf1_(x1MpcezJ!u)qk_8dQ6RhWbQA5ET(U?CZPq zAEbYc2$HlsoAa!y%N1r}xHq)dSxOs^m)G4X898fW0V0)6b9G%^PhEmFA4{rl{`&OiKrs z1t!G9{GK5p2tda4h21;ExH}ci3foF|FLy9P*dIGz`6JZDrJha|;qkwh5x*Pypf4F* z;u+x{ksOp-6jx^{={wMkmF02)=9648TOnlKw2KZVwo~{W5bfg=vdbq-RNe3N*s=Pn&g_!B3Ab98yMCvqCwWFPDH#n7OjB*1oHUak zXId!ry|-@B5->u1UM!+3-+qhv!BV0s6wf<5)Z1<5zuE?dVZA=|$iR&oEY!pFVRDx# z)3rKA<{{lDDV)g~Z1^K=!3hZ=iHZ2{eu05&e#>dl%BHSuT#Nh>o$u)x6z!K@n#k0% z?(s&_2cst~N-C~C#qGSki(anzpbw_6cpB1vRa(Um9@&tC#}Sf{K(Lg`d+*i|?LQ>zzOJ+G`pWgHper&e3a1z)%ed@(b*G5K z<2B<(jp$cC+qs?zq;Z)M40nUA+;PZ&68RuXH@b{@r+1k?mcWe8!p2Nymw+<#2%h`4 zFF6B@1QsM~`4{>yn>#Eq00#5%^U|1N%Dmm@#6>_-)3ool> z2@a~TWc3A25*T5jX}N-~Sjy?B9lpXa<`nkTJ&dSD*YRa2_Zl6=9~pV+rGAzIJ9)Bg z-@clW;pIPZW)dg$r+bwKGpCriwAgSN5xJm* z=tdH_7^shW&mCvQD#vo6W3lM*{LM+PqWaN$gW^ z@TRPdfv-NVKgheqgHm*Y!Rw?0NnYjLo7dwy7RnGRV|F$!nen)TKbMHUz z(-Ioo7#r4*6kVI1Qc;vvRz?XxTw>z$w_ng*lB4>?VM$^5-Fzr4FRagQv{V?znutLS z9W@J#@ESO|8WjzWJ`=s{=gw3Jv7Pgx1byY%mH9*YDC^xX+F65z;#e#+#HmmvQk!th zZy(Sj3#S)ngw6E!@vUEx)5;hHHe!s|#pZK0*t&1lx_`g@;K4rLAPGif7K!W<57n0` z`+!xLSn!rG!abx&X)vE&?(mq8Uf*@yX>0vz^p^M4#E+zAj2Bj2ax`Dt-SCA`y{f?( zWAqsnv$|N8B)%qlTaSmRI)>SZPLMWr%8mH^Bvxo)5}B|<8yXT1CW`nlc^q8nL;7Xw zhMq2O%g?Gvp-8*9Ij4P~mK7Zz_C#ES9s>fpdQUz6Q7&<2JnH`Cj+!ZQJ9E6E?lSNiTJFTBjl9A%v#!yYp*UN~pN4 zzt%L>>NwCdeAF_2$__x(YE-Jz>PG9f|B(!a|4;F(_2cV{OhxL{<9P-u;wLq?ktGr15j``b6thvNBWmHClby*usbvAwgaXyP zhxckx=zB1cYUKfXAO4l=oB!kVri^4Q`yb0(<+UP9s04y!s^udqm{+)BaHT%1$7N9K zH)X(Tk3Q~Mmd_WlOMin~qhCoHU0_252tzgc0?-_chqXe&XPOEO7dgWKmkqpM+J1mX@_P zcJAMAp^W76gHhY}7x1mkwil z@aIF8d~bq6F=AFf$(VnyRnqyFW?w#Pa7`cdhUa1E}pP$dhamv@(7 zBjJpoH-#PnCU@?Ld1o)Z)c3~Oz;DI5{gGSzAG6w7Hy5ayH-QxD;sDFRgJOMvLx)_g z{h$M(N7QRlmBsau^vHh>y)_p)p81Ik=3`>vBfla?>XE~JSXS-+k;KR~F_bLJKmrc+ zK@=CY4%^4P;Y^1y-0~){cl*9NF?(^Op?j>61=E-g!-B?-bl6?}=JT6QJBs_fCT{iY z#QM?Gmcb*Y>`x>w`^7TBOR^0bVR?Yye4Kiy*w4sWZy@@ca@xWtMD}Wj-Lu(j?!^aT z0Y+A{l%=g=YN{%8b^7dxM}R|PM8&&WZui9(g}RZtM(~EL*J9QQrgho=vJKynnN!+; z;@c;4tnbQJ{hn026wI)FOX^lc2TB%QOg91_)olLcz_q<7==E@TcbLtcW^jbZCgC7EgRVFfT!3uHO`v?2J)02q z^3_@-o;b_w8|H)(`Vi3%xxhFb>nay{JiYu}Q2L)wZ%c2B`yV(b_o)P_G%i1qhP2cF#x%uOa)A6 zF*0%~Yn=<@Ltx86)7HOoBJQBJWyD>K@ANcmX&x}JS%-QSIKHEA+)VxL z^40$;b5EdhbcN-`6KHk@y8n~cw*R9{%DY%g9nfId4{oHvAo_2m-2S?@?beQFM<+!{ zKtp|8qx``53XH%uZ@t9@*v~{PMX@3r_0BtRot_tvXQ7L!h?JwKTh)%&Zu!$KqObl@ zq{)O%`H{pad%Et2+Vbx&U-kE^R{rhE)!$#mw(9#UMI+g8BK}phdC9*oar+xLam+eh zBkSo*u~A?t0itFWizKGZ(Qp7#fCflm4=-W<(Gt}{(NvTO+3;JpC|B;?w@-hYHijii z^Y(2qAs1C50rm0db#)*I5A@+Zn8>Bz@2e`gA)ujhf`r=mE!f8}gUtUD^cEj3cK?0% zjeqy-3gVVZ9x`5R2;?7VZr^iT`}MVvUkq-)TjP=jA4G4)n*~q&%Np#Q=l^Cao$#xS zuj$BC)Mw(wq>Qg=p5F~|jqmiQ-;4QH;j=&9vhv5P6_1HM{DuIBEq|ab{m#;j-`F1g z<-Fp_;s^NoG2;tH2>yczu0e^g5DKP83XT{R6~HBItrDyR9uW$=vNf!7`5H?4!WdMq!sb-r3(^NEt$q1wo=Ca?SUhWHEV zVxA+M14ib(1503}Uxc7V0D-*!pg@YKkRgm<*D*p<1wh_;2O!XXR&t}Mn1wtVfG`Dy zy&&qXx0IFgtI(^cek4Zj>5+N#QjVo(_oQdUR9J!s*7IeLe#naIf+UuibnX*9gr zXuj1tdeQR0_&%Oq!^}YFZ$>}y+LMs4rnLMj<4a)@{@{w=TUq%<+r#7AVd^kl+t>ZZ zUc>tbjsNY0`3qqg%O1d>~=QMpYOh_FoM4+BAE|;T*ij$KnYcs4=ZNX zv9bYH$K`$;B7#cB~g9QX-4=(hrN{yFh*x{>a_C=nEK9O;JbW(t&W4 zu1D~NC4#Wu@Yx?3=W#*9bs&HsUn0T^wIH zXW{$|Mqn@%*J3Un>tiF3@AF4K`APm1_av?*Us28R10NSO)B#FF0ff8;SL!oQWm%Dq z5en2vQXCZ+A()2bM~MIsA^fSpXD42yE*?U@kGbCBm8lqAF8^J6D8PgZV0ao27EmI1 z>qN8^?Mjbu3Iyqq2N|G)*hP95#~037I6s3Ckuj0^5riv?h$*Ev9Owel$JkCPxP;@({6vJmvWvw1 zrGbPRqUeQuH(H5!GA58%Xz2EBrH>Hx7+1tU+4@-Uf8I(&+yHw|6wS)FlJQ$q8yBM% z2|KIyi#5Kcr%@KTFr+ovILn_ZmdG_|5Ntve6B`bc3UI04e$alAUNL2OaeP03pC5@4 z#Y@DXFpbzaV168dsRuBEU8G~=e&z!Uc*??w=Ji;-T z)DJ&&zew-m_&$=K7laWt=NdWlk|;nzkBBUuoS#SlR`}QIW5C}QibTZ~byafdlHmE9 zH*p6DBXd?I(S$l+{Xj5s^r(ubski~SAV(u&wxl+sCL;SUg2TIatB0U>bd)KW01)(u zgo(O9?12d@ct0wYbMKmmj_zS(k>17em0YCwc|jOq4yn?`w`H~7>w{F+sCcX}x8(FI z?j}}Ek#bv)BN39lb4SlmkiwJ2Ej(FRS(GA7PXiNdEu}|*0~d4l9!5x!gAr88sZ(Ov zRi~QZdV*K?veizD3#02HuK#FX+{4Hsy^G^JkDnin5vdNavV=>b{E@5DUcD`!YIzmI*zh6WMIKAC3`Hj)zl(uqJRh?w)`%Y>)+ zEruCZmQW=(Zs-`1>q)xY4QhHnNR@mvNX)-_k>17e{a}86Bt}$>SC8mEjFCHoL}Ep4 z;iw6VOXa)KAOHk68P>yU!fh8hdUS`%Zol^)Na0ITd!puKWJE7{1tz?s;m8r(5J16i z(HhiM3Yf?jF$=FBJtE(vshC=m$bdd_>%4K{rT9VMS59`MfmJW z1}=`TjQqIx`C*K(R1U8ufv4`nh||^*dgRU^)&7*J0~1meB9~{7(IolKM8G1_5V9g2 zA4C*9Q1>Ov?52jG$#Ou3Qk%F(SPZ zV8Vvor4Do)IJM*g{gFj_F*04Y^y2tF%+C*CgoqFTAxs3nQBR`Bex(mfF$r-GHGAmZ zJPuSze-Ghbpn(#>eFlBPOp?YD@m_F&S^+E^5ZaN&d4)udt;T z$JaG4=~4VVA0u#-;B)LB`BpfEk%xs0{)l)H0Ivg(#Z;ucaocg&)o+0SmJ&)qcPprv za=l&g_HC{qXQ6nQz0f8jBd8KkK$sV{<r0M=|u)Ej_-%^^L&iV7qB1i*riQido~K)g*=x_ z1S<(IbO$S$GnY!H{{V=Z+xYPw_kaCYi}e2gVSE)v5V`Q%;G8HR6l-nm5o&@eDZZhq zkagQQE8cGTx|pL4?l|U68Em`@fKzl7Ru;MdVJ=?l<9rJzp(-pN;aM=D{>l{sxx##s z+5s|F^Nvyw6CvfheO0#qL#5P(10qxHK!6ApY%iP?6{=E5IeQj63R{cc!m$Lq$dw3;@MaSdj?#GZeW^&adbc(9}Qb91?_hHJR YLLwNE-pwNc!k3HmE{^ZQ`5BD-Z_iK|A^-pY literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/image.gif b/utils/wxPython/demo/bitmaps/image.gif new file mode 100644 index 0000000000000000000000000000000000000000..34b3e035701d1dce9ee3691e970e30d71a9bb456 GIT binary patch literal 7116 zcmc(g_dnb1`~D-utTqX;>kc&|RT4pmR*e`{k{}3*AfZOB7}2UwyTfdSYVC+s)ULa? zQM1tsEv-(gHL6>6zVmtM_mB8qznzckypHpE9A{pS*x2Ds5BhxoS%J1e|L|D~YAQ}xsV}ocs5KXYt%f^D(G!UB&V)H<3!Ol}2 z7Q~~0cx(`l2jU3;C6E9M63{>bHb}q&34j972BZNk;4#oG*qO6)Xjm*8i{)Xlf}OEI zMWbP9Y%Gn3r3rQ@fJ-(F%VuNQJSCiWShX0yb8_!wP_@ z05u>6Km(Kj7H|g)2DAZbKnr***fF$I1BXqc@n|%`jz3^5P_fxGHjl;@?AQe;fJ+{m z#^cd=0>C{01@zJcY?^>a69D#rJOE7KH4q2jAAkTH0@Q#Q01Z$AtpEow7|;f!0WHB! zay!>R4ICbuE!YVX@CS?qDjtu`69Bmab^!|Dk}cq|1wf8K(m((J7tjs_4Y&oO1o8kd zf!9DB025#sa0pNXVgNMo62JmDfWd$^AT8Kg(M~sT4b;F902>2>1pEPGfr=*(>@4u_ z`gbV)Zggj#f0wia^*8sO_5O`=hw*PZJKO$icnA5fhn?mB#oBT3cM>2C{2YKS0pS6j zfKmUy4tnPc*!dPf;sQ{U`@(cu`SDbU3|wVjL^&eOyAcGI6`w-o$TW$NI$EjL=3rgw zJMp%P@my^u^&{diHA|M4s(PW$=SAz>y$7?=9tD*T3bjsv_dbczymxK4+H_+O*5C1p zq9$g`BT~n{!Tt8>7ZV+7V_ApqWbZv;yfT;d&;5GuhOJQd0udp^E+YfzHFJM(R)uo3 z4${o)Yk5bvY}HBbA=>jPFk7Dg`oPi4ek?phMa#E-CFewIxkbRvD`!~bGN8GUnc|jSs%62?zXS$H&?j5h1 ztO8&4^F^j;Qf*zhRO;n_!m8Dy5#Y21hXKt(d6K~zKTQ=}MD?;!+bZ^oEZ6Olbs>7B zy|lE(YhBNa=T>VJkWD@QDI8w0)x6^NUUu2evyu+=S=+1oCjaEoablqc-n6tR$nQt3 z-5=d?$Z^cmz&VA^Ke%Ex|wsSHTngM`x!Wjea3{T&Oq?9J3?;gq7T*GUa8yZx>z?{}ObAAZ&064>B; zC-vWF>UCBy%{c`xqi4Byp64xw`^VTNRNmX={D^CrVJy#2NH&;PZM`eH7|{<6S$~__ zEP8Qv*f8+-KclMKqESP8mI6NCgFXl~B>&5(Lo*+|)Wo0pFS}a3LtHei$(1+-%EI5Dy_ZZYzTBCcO#5oSXPj{Vp8xs2ZzSDgYX6nYAnuZ* z7xD5-QZw42o9q*hR9t?sToXi#5UpM%*Vcd4~m zYP^NI2~{kIlCKNQuAui5Wd}&q+Tb$c#X>Aa`l*ij4_NLoy}TvMWReXwT;!6{xc^vl z@tE=ZcUO*Vs3*cj3&6uxBn90xH6yld7aD%TK5?%`E13OdwaL7wJw=V&I_{ukQFtZa ziPEe&(NP$sc8Zi`PJU{ycDIdGa{CcF(&c_zH7Dt+gcb5zGDn^iP;j>*6SLhf8Dte2 zZeQrT?^+$ynoHLyF_J;n;nWAMTjHO8o)AA#d2fI07yVZv_Nku{nIsh|f*HU285%Fh zb8V@#Sw}xKUQj5ztF|kTw&%Xts0A zTxq%@FmdO?6hy5-8lrl>(iEcsJ@lAsC9lL!!~4sfDheXsURRE}yXT7V^S!nn-yfKN zed9@ku}i#4dY^z@+%~*TIDuRyARE0 z$5PV#y{Asd@6MYE8l&!+FoNjGmhew!Uqz&Jrz31jXUx4=c7rga0xKcST<|+L{_;UB zJC=p~RR75N4iEMOEwk^)AV+VdR72e5(N35Q+Bg3BG7;9Wb zn&eO%_5OXU)W88}Jr41&5j$=m+n|id+;zhjq7$SEon0;?<2@z+{Om&4`qm+C9QK_W z$?lgv-sEdyucha;pwtGvr`o*mvI1FLXw0GoII919_H_Hu2>g~gSmjcnWB>%?etg&Z z;SNYFt6lj04F%mA8`w$ifVNr_(r8h)p-F^zoJq|f>5jzcUmVG4AHS4Q>CQ!IXl)r~ z?P`Py|N1%7upUNA;4r1R;R*Mp`9pHW?P;H;G_IGP)x5mWHlH@%Dd;5B4HmjKE}Em; zhxEq2NZ#mALF~~W6CRw_Gnb;U(w%LB-yfjV4hLDy7D@@7LRY*{D!7Yl$cZR|64Kwj z{yHMEj~P0x1>5_e#)wI=O1E>YVd_Bcj=Ezqh05FrX`}k>jZT@zZ+Z|Q&Z~v`A)OXY zU%WO@vZZ#=Ihg= zppof@L793&81>eZC&F2hQAQpk1|=erN$*2F+{a8olUMQrdJPns9_z#_hACsHDSfQ>`%JFq@}ufBFi+LJ3L;yVu)T3>6~ve?WZ>8b!3iwX^7hOuF=`Q2?^T&vEL^DC8$d|eIC@23J5s-DsDA+ z-q**csxNc?P!X|@aqwZuW-M(r4b^QRkTa+QfVe= zun#QMXdc>@o%z3+H_p#B9@%Lm6)ejt?KZ|a&z^0?2cGW?gS@53*tlxjfW^w=q}<7Y zTk`e@aTMNX$!w^A`h2(gv{=6uWb<Sy$l zA%qri9RHkd1wk`5rDL1rjPnSWllH7LTe4CxrfNRPgO}kF+ukH67zZjv(zQk7*Sg$S zGSD$yr~O<)t_MoCRysIqV{%$$lE0)sG9r@%oz$iXX@@qklctQ_L^zA3U6NsPy$&|p zPnent{5+(nkQc4HC99f2ynzqwojnVNW#w!+C6hy#ApZpSD5-1C9SXtg+Q){B)qcpG zybU9%Z&PN-Q79TC7Z;^xPWexZ)luir1oajsLYUC3Sl6uksr%?~jk%Q+M+LpMHz7i^ zCK8BbT+LyjI&)I$UOqxRWy<;CmYE97vi0$$@j_SWt5npt(9Uh|+I|hp?T9gXJtmDw zsBw3IPW;yc7*A9OGX<%F1lTyqmD9FeOn3VDVg zPRQyT7zV}`Gi?;|lA*4aigkr)X6 zAQY^=?FH|m|7((ea#(VA4})3m+~^xei97$!IPsWCgq2nRtpLg$(JqG(y|0Fy=R^p` zdLGpJUJ<7z) zp~sILNpWF7AasaRe^#=nk%1820i5oA&{tMoShJk*KC);bF!!EK+#gLd!xpi6c8<$q zD8V2MB^Ls*P1#+c^eMnDC6bgp<=0}HTGfoEamW>`v_UGhmC#7K*!C##7tUkKUBKe(;SeT!;N~ zABB%R6>^P!H$AM)BMhaT9>yh^L&xNqbLWEn(p776Q-^h+PUYnh68@fc@=V$d zhkUw@P2Am2*S&O(-9p?fT4gk5*h{sG1++^(G>J+V58s4H3zjRGqEX~H3osr2?v3|9 z9zH1Jg!3a=%AFSQg_}>_6rs$0=84{N!xv}S&TBPv9w%G-YKl-fINq(gIVi)RLiq{VkL%hxfj`MST!-C#g-UKP9ZU@Q)YF_l4*pu?RU>$$ zky8Y>h%4$W%3z^n$o_VIkBUEMdc*Y)7}PPn{+iiu7u&ey(c2-9gQN6qS`4#vmb0&3 z?M}$EfO(B`>QSw(gaSWzAF=KF$+{fvH#HhRDd1jrvr_t7b_Nrl@@hF=Ye6IOdz(mB z;b1L8bEFkvv$q%_BcnyUKr4I{Ai2DD+fc$tQ;lobDp?D?QskCkX$><+`1FqEam-uW zwL>udSKUfVgcIvEiVdA_Ybbr*f0<0GF7JUng$mh6hH(fF@QJRaon<3e#9Dfkvs@1i zUr$m>SILUHM}`_{R%i{tTt_twlZh)e4v#fBOt%i%YdUy7O%Za%?Z+u+f$Pcj8u}Cp zC*fJBM06_JmN=(Nk?&9_uBVd^FDh`A|ew~oZN`#anTtDjs28(s~O|bKOijG}O8P7VrcEQZg-OYpE-);{)JiLh`LsVo>F$r44}1;_6l#D{#wYGBrxko0zcEgi)er zV!e0yt_?<%Bq|iXprM~;w)U8HSJy{uv|D z@qSxPm!y>Ld8T{;-Frzy;kSFusr36d{@l{pAprgbx$TP1(v0Fbs&XhR8+A(V4LmrFIctYG9NNhF+|N@LPti zTuBOZZ&R)P{vMd6mG^cf>_5Y9yHBd;jEl)O!{Tor7z$bw+tHPr-#H3dwYDy(_QZ%& zqy718I(<#Ev7xVLpz=5O(bfcb=m>r>GDfx-HZ(iTd6tc&XDrTJiEc;f4O|g(3o+!P z4}VuiOc<5%Et>oc|MLqKy<}KUn(>-z?t!(T@C~@h%BDKHKBwYTWKd8nVwH%PQZD!C zigmaYVbv;M@fn)vrzgzs`RUoknaDe!4XdI}CoYZ==b`k`fnSM95ed*{&J&u9Ow=33 z#1Wa%mDmR^c34>iH7*vNt|Qz-jX7!N`jKbw6oZ+fi|Ej~lhYnUuu_qu@F!*+a>6nu z2~jrpo4Qr6G^tv8u1#)VxoK9$uc z7LWWkhHpe8HrvBIMrocF#Q}#D-5YqD64#{tGD0||@$Y2ouOC<(uxP0fqlEcH$G%!W z86j;bUy3l=_SZvXJ%eP-eZ>WeH>Nwn9k=DqpXu&5Lobwywcj;cs8382)rp~5;({)W z8F7!rM0;tg&0?PXvj^o9z$E;5f!UvKvU%u;Axqe6j_E9yM>53h^Y>Uc4Lrt%8>}tm zH1)YHVa>D(gqoEpO-#0$nyt(Yu&{hcEu#;A+t6eA+=40R1vLsBLQZCErK*Wa$ygR; z8qw6sDh=Z-Yq^Fbmzn8TZI3_BF8B#*_ntV84{(V#XR++NvgV(m!Gn`%zCz^w<;Cf- zJT>_IZ>_!YR7t(%2v=FbiRKS}xY2eG|8>>yYw&-jS>OKn_#3Wx5p@aSE8dq!+rtkV zEgm*E+>m;XP*r)?Ipc;Bf&~T3E~?ktA6Y;g-CHT7f>5i+7|Z?1+jPGJ7q>JrVs+&% zq6_7mQZZ_+E30F!?322R=KGLGt-MX~P^VdW89pl|_5EeynuN^W`zdO78Z~5EH9A}6 zXEt?bhCS6`3S(w+7E9z(CGMR*nG{ynuV#}Q>Sw@_;;KX!ew)?J0{P!B;pK`dAH(4O za9k{VIrUwX{!` zJfwVdT{++!yuN(&pHJ`n^X?zjS~WYQVJ+vNmiM)BzyF5?PdjHha9Hq<&9|jLr|`A^ zY8zSFx10aKm^{}&)-E5OgmDK0EG?>_tuK6&X6y@=9Kq`H*%({a*Wf2c3(5UYyhQ>v zzdqXc5}{Bj`?Yp4^NZXdf3qh*-eX!`{f4Qh(fb+i28hIZPeK5VX%pPb(5A%QIh3Ij&C)bLD!ky)8H~lTI z9JM}h=)-6K3yNF1_gg?6)=0sJk8wFB0-=E0t=K5i|NgUc!D*tU4#i~S{3lBS^DghIC$AMZ`tJ%)yC3_>y51MtjFZR=p``onmFt8*fsPFveSA99^QZ4b zqqbj^uH=}yd;6gSXO;yGEhiRu<(rqijxYnsokc}$4pMEWE!&w6$9A=6yC5%`DJL17 zzy!_Tu92cWdOG~+^g8SN8;66XJ*XW1UgJU)=GVmUpH?1nd|v(U-0vS-AGWiIu6WS# z`OV%YDD#$4VXyoChHfKCtBd9%NS*HM%&3pYgan6!uH4)u8{7ci^Jwi(YCz&fMS+G@ zsAhi4#ye91hGK7!w~O-7EHBe}ll$2bbEVv}S3KXM9ep-a?ZxbuhPrX)%)~9e7U?vS z)0mrw;Xsx5)mTnrGAr}+Ni{>c?bJ&{<0=#$Z@XOSfm)9UTuQ5ew49$~m|g9xVcy>+ zZlsse%Ws~f!rM;@WUf_)8k_f$2p0>H=W^St%J+S#XfnN5KVmL@8grO~_J=ip?#0-) zii@ShJXE(nflZ=uy<3C3AFm!NvR|~0Rg!-$4*&vz0L8}(@GuLI1%N@IKlkH6 zdb}a15C{?y1PuiR85IK!0|Olm9UT)37mA66gN2R`C4}PO;S&%LU|RO=0MQ&?wy}S3y?Ub`Xy%RVIxY5Oo3=$Q z&(qv&P^m$XGo>ILnJLhk{X<*Ud)BobK`Q~awX*+dI-UNyz?08LW4)_6UU*@?-cZ02$W$D9Ge35)b_N57gw3cu_DJ|WlkFXn*&h34%~&Q zPYHtPrl+nAy0`OphEeY6^lQ%*Nx0HluJtxp*D3HB&cq_OUpMeMXX1N%Y93c^Hk*7z zj`}3=rFb8?CBbKxHNnLI=am-xNgmd)qf>JLH9@Z`)swif&+gLBs+TP?8aHXI+k6fj zs)(?T;1pdvDEclNR&5hJ2OZfto&u9M76UF+Gj0#`4|aDPUlSLwBWRKGqaPIFVjh{) zDR(mt_EGF^z!JZRT%?u&{ag)}Q7QK@==7gr(j&GoRn5&OO`oRMlk(8ii0*$cYM^gH z`%zAjpZ|+uMc__;9!UzlXLV(-oIqr}oxMeZF>w63JTHgho~=cE>Dx!f7@+_V2#5qk zdgSyU+8)_Of&g&w@NsBp>3ER|c(|n>*+YGVfe?_!Wg;R|jx00~WS;z< z&L@$q$GCRN(5Xs9c+O4|w~_}d_~Iu8|CF=o)H#Jv)$6R-E>ILT8`QJC=4DlOPjmZF zz*TVJH_Tm8%FZG}HoW1fKn)AXJFF>zG66o~i+U04MK1SA(`LB&l>18eyEmdxG`7G> z=~?7)tM9>-7bwyaKT0O#K94`{ow74%qFH7SK?EI5X<_TLfW6eaNoHT1{a)wB zOOQEoG$a%#9}u}Gd3;YsXvD}q#k3=yHcx)IcA8q6S2EEtn-l4(dxd7OmUvY4H@K(a zvvG_PE&@iKyssz)i8a#R<7DfukzHX4s58c$-#B{|<$l5%VSPJKW)}gP>yTA#_3E;qpm(WeflqHiBg<2tgU>rV;Me?Zp!I%RlQGY9(W{hT|Gi)eKD3;m2PVb$X1GuJmp zw@-xwTX#;eF{4_N*z#*v0uT){9)qs*|F4kx_+y-M;Q)YOFc29D0{J&i|D;+Z92y7| z7mt=(TEi4JjGvIRe8?jcRMmd;H)0<{S`wI6IF}=5^Ii8)9IbwuSG7SVayYtt=?www zi`7ThP=Y)X!?shFRf}@TYDVQI9SXx1(DS*8=~~RTGZvP#ozrb$xj8SnK#DIVrx9d^ z?OB5WXELgbX;Jmm>M@a@)*8N>qffr1m{PDtD0YzeP{OhnGR2)r`BtTtn+~7vE#-L; z^wlQYQTH@{2pyNxR>`tbBBcd&f|*WO3TX<3qhqprcRy}S zZb9w~?2!wFKOO;$Vizr@KUZA`TB7FLoG|^me<`ZLn2=aShOzkb!=5E$<*--{S!=OV zT>3|CYm`tm%D>fy&cKT-rP*U*KjunfWYBuk?TNj5f^P4Vw5CXfWxi#?nKPLbFhfw#@y`MO{SR@Ma;Z{(ZL^Mc;7OkAo=GmCKCJ+s zmvR~i{U3e|aX#`(hx3?+9|sr!{!>uE)6%WG#-yBKCi}KN|j;jJsZuYAXaMo*5eyk#TrO2Q+P)@Nv zW<~uWFP^&z<5gZ%D&iOvH_my>1zxV8qwxRzvE-w(c>WeG5E29gd8}K1{Po9KxL}$; zf$-=p*fO*oNyaQFhmKb>LH2#s@V^BNSrSyCK}NIKPo}t{P|dkWc= zu(P2Z-wsH*Xf$30m_=#5EyP>&G0GK?ZA}(P=!&z^Hm}Q9qweh2A=66$t?U@+6RcmQ z2QKA#9N%^m7Crz}m|Bh-o;kqZvN_U4P!1LMI4fpI!;?z|KGQ<%L_%xx2|d&G1!HAAq~r{p~)OKEWi<}Z%S!ffW*cV7v#UcVLEIg$ACeHG^-A}Va9IW8xntQf7}qyn~OrhPxE&ImUB*+Yoh zT1^}*e1Jt7-cxB4l*%a{ah5Dd9M_~`BuKF9kD=REN~z8-q*j>MK>Lfin4k1_vhR~* zg{hA?9)91Pn8Fe1ti$^ImcIk&E7CLf4w&<}SX-N_>bv|mFZAvgrFj`k)bD%lK;At$ zv6Hea4VV55&f8S{;hP=5JLA(9m5NcqgMcJZ2Q@qwxgqC{wXk0i#cTniDp_c+lvqo` zaZZoKijOY>El3(CN44zd_IPv-rvkLbp1Did&0btTxwPCNh&$0xuxu!ul(x0x=oS7j zVPku*Ioq=ta~jdgE%4;d5>{h(1kg*4a)Vb9mv>g{V zvDfjQi)5~>7fXvb%0a$>>HuMata7WlA4WPL~$WqG=wdw%6QkUW^%dG^6|EAy{__BU}W*J|&GyjG_)K~t< zhIA8q#id7W&lw@OV8_am1(l2QX)L&rHHewbFPDuEN;P(U75`x!Pi`-YqjS`@bUn@+ zIWWEG-mqAiLm@+zry5{i6H>X#Atjl__+S7M-!i+F^hZjz>bFFehfAgdSvE%1r zZ~kICbeS%HREMBhiubi$qw<73xasIjNMZd|)nNHvvz+5$y^AOE=lmag(>}7bOJkic z_VoBpuM9Q9YRKxI-~C#WXNj!2S3Lrz7(P!O2nf&&5CU`G~ z=GF&^EESM+ERT3mf%5CH$lUU`AN-`0X%=cj_w4uqlfO|;uNQ^Jvfby}ic}3A0D4_x ze1Z%Ooy9ujI65g^zW`{0tkF6I_TT*EIG1ZrScyCE!2y+T)e~A^B~sfBL2BtW_n#w* zyX7}ITpF}pNR~w`1pF`q&CQK?w6iLeKb;a0RsVB<4dM_mgjiszh5~zw8?qN#Z4tgD z*LEdyR#wTNT1gvSXS^9yz?!zvkh4kkg!tGUzxF;auQJe(s+v_WV((9~WQ0C;3Xi=5 zeeFI5gbSrW&x}poE;N_QT~P=zltVNgBU4(SnYWbIcmi6G9`SXwNt8dN|D! zS1Zt`HU^H15eg&B%8j%nh3E$+;o{Sd9PyZxvsEV|=NWVxzwZCllx0SpZj~ewWQ>QQ16(F=Zl(A8ZQTQH&gbLOCaagJxUjZeO8tW!)o!~} zi0CM?Ds{S?JzBg&&+@B>L%MTJAtknu~ILxFRjP|Wi4H0TzhCw5EsEOFms3f$lI}qOavws#T|^s*Xl_5Qb5t3f}ByzOp#j zti{X+uC@hHr6cneYqkD0uZkj`mSf!Vk?lxdk;Oz2Uz^vY*!E~{+gML^GV<)K!YOj9 zTdM3Sp|kM|qB4eJ9Jo<@%B%-D1&zks>ehzGaCJuvW_2z85q$KJt>N)BsXb2=Rde*E zjWb@)$+hpaAx2eth4CB!=JsO3n|9;(bpLr%!J8)9JXDeN;*6Ohe5!-g{%fJr6k)Mg z#xK2XGd7V)5pHN^oeV?~R(#3)GOXAb%$Apq|Qq4W3eo)Yw@p{5sSGvFe zuknwWRGy#gQ&B3~~JvZ#m$o*ZL@#`s)BaR)^+HFD!G-Msy{dh&agkqsozq+{J z46+r}+ZZ_b<7B%a6?nIa#@{7!2Q_w=48?=U1&imTbq3ea{+FRks>biILiJMXbv@jQ zhl?kg&WfAqac@*7ydT+X#$X0A? z&-g^R${wxaqIe^(^NB<^cr+ChJR!4m0Vg)i>GG zVeCs7+ZsAfo~y+bw>q9-LuZpSp)O%c5BJZ8Hn2nj8ml9}>uFRP1{on2#gihnIjOu* zwbH#O%rA%Zs)&_KImjw!M=)zi@fp4#F8it}GrD=Gr`+~fMRxqxY9zV`E&k-iJGlDkyF&4wyE0y%;{iEq06iaTy%U?q$2j{o}gf+pYTbXK2SU zM$B(!*YUEn)FS;tYEhX)M2GV1xHxL1K8kh3#|-zNLXHDG7ESJ&PV`9-8LYC!EgOr?l;_DY6)yU?a$>-^{vKka(dPZE}Bec=iyNz2oLAR|j-2 zpa>!9BBb6&Oc8vX*wPkfn;Ks5<-m-Y4})~p=lmyE$o1Qj$E^JK)aOJ}~#u8Zu>AXJnbqd4eGx^XM0^TsY@_+FCs} z0grWn7Uwbj|En?nkr+T6z+)YFRE|N=oP>Xy9?nv}_;vnd8V|#5IuLyY#3Rm3XPm--Sh>^w^l_O@8isX3Q89 z8*l)K!s2~(%rAoVp?B+paYu_|E7i^suxs92Pgd3UfZuySYYwL6A&G& zw6>KvhVmape?cMbv^s(J3n(-xNu0oit+A6G;=B|6H?dp?so16|kC<-;$=5GG{ndqk zNCP50p34147yhZ}&0#F^I7d!mLaT$9$-21Ss)7g2HKh<^3gxZg z1qlxTqT4`BLfhgl*Y;gycH~K3Y$Bh`JLL z@W-7D(EkR(zunN^AkdID4N8Fh>4k=ukN(>WL02rIgiNe`908?KT8{i4k! z(ph&_W4Ux`UB;IE1ezk*~C2j&Wi3unG(lz6sft!TP3aD zreCEKoPG$DA}QpM(a#4tp19yLvRK#mnOq)FP#huw`F*JY_u~SfmdU6lfHz zIO3ouSMvLob3$Q(PaWqvI?v?ZNvC@XSMnJ>5bSHqW^h0M!``(4)@gj!ku?V;Y)eT4-_Kr8xjAXgr3_Krb?Mx!re0q`3 z)o1sFSYhsa2!mE%(fR#XlZaoIO#5aU#s0{jMB+P;x*Z8fgP+wa?dK%fSDwH5h5s8x z`xa-l9Z_8;6HSAC*5@|cnRqioEK)>UTY5ZPTl#@nb08Wy5EuP;BksuzI8Y-q%bM8z z2atM($gtb~J1sm`HIs;40nlHCF7GO-#lBR_TIEaXXG!4G=f901t$q9c0Z_;A?uPbl zRk%heDZcZ`D%y2DM^WJI#wy$y89wm<(8pjY>^>w$M@d2@m~!Zpp{@#*^Z71BY8jj! z81=LaJCDO64Ic8_H?BPpF`S$zbBvu)bn;`NU)@lm60LTD9^4-grVs?nXOwj`K10V$ zF8*Bf{wM0$5fE#!bunm_$k_v+mP^f|8X0@}-A`})-B(ORO{4W~m=kRo zM{&bXn6NgqWgJkyq*q?^Y&=i(R;#POC8p4olA8VOfE@$ilahexZ7e7;?ZI-3yEyq) zX9JZ&Y*wfgdb7AirOi@M{hZNX4`G^g=VkdUw`G?)z*m`#CXimL>id&e8C5S%FbebO zMv`6lF9pSui*HF7kuA@exYVp>+H+LvkV}4;aF(rTpCNTgDd??BPX2sPTsDtr4D}?8 zDT@Z_I^eLxpV9=F#>_r(it(!%{2wXmpK3@9lvCCN3N*8cQ zQ1*fS>^I+xl&ZsR&7gdx6wcn3}e1*${75I)Y@tFCkGD69ZgdN#(>E2?Nm`f!yKzV)y^V)zs5OGiEyC#3{8eN_ z%gUVE53Q=hc%O?>EYYK7JN2A@?*yl!Hu-k-Fh&l`1{^dYbb5uQvcS)xYQg*7wd^(% zML%NHq)w_uyj+GUe=6@SaDT0z$Ge5ScfvQ|WcFRD?Ls0?S?a@S_Hpv;{6XZTIdkdT zhRIXyrM%!KwzLlN#>C~A!fsfZs>w6>#OTwDA}V`jw5?ykaDKo^CC0M*mU99WIc(FE za}ag!f(CVNk9cGLXRD&T0L_^@v1Qmx1JQy5;Vc)|ATjv}A_ocshUX=<8Ok%}X%!9Y z*mOeEir=UwOuE`wm)X zkY}p{bLD2AvZ$J~xpE}6AiKIP&|_(izIM7ZqP;&tN#mm2+U=y1)fdz!u%pCQQ<$EN z&_CL4@56^sN|IFQ9DLuPm>5xrt*q*8)V(D6@yk12SXnjb+nGz$O&6s_n{VD%j2O(< z^RIP^y~Ty8tY0yh_Y|QpzrgptwQA67B}?@(d`>CS(L=j!xMa;Fz9O~GE`WS6{%cVa zaKZ?lr%1K1u}A(5Dwl2F?!6H?Vx<%p5|#sjURYrdT8Y@AU%njjP=Qd$HH3m*`; zExES?w0^|5o^#24y-({HLk@tT??oxRy3z@jS>daqJS5fq?C}7|SoX9zQaJtpIrm-4 J4avjw{{jP`!K?rP literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/image.png b/utils/wxPython/demo/bitmaps/image.png new file mode 100644 index 0000000000000000000000000000000000000000..5a4ce74b8970c81980eea62df1c214d9ffdf3a40 GIT binary patch literal 17905 zcmV)RK(oJzP)?F0Y-MSe*{ zK~!ko>|1$kT*rBznRo5M6>n0cL|wElTeeO+v86apB*$)jp@3n#NfW05tfpv+HU$dA ze-!N>K^hb;;Gjs*0tRg4s9W2BgIM*U1gaz1k|oPhWm%GSQYR@c$z5{Kch2;i`QCfG zq-c>kf~LSeJTBk9eQ)ObeKX%ZL$_|-N-3=ksoQ-CX&d63Q6S2-O&zM5FMv zawJPAB?0GdAl!ggeM4vPqG_^1!QZ&CL%v6;roqYJZO-8oK_K?*8L=!4uHga3sIF7P zfbO(ZN>8V?y?e)&FP{Ssm?peU;Td?vaRSHTwjEr&Sb;k$SI!9nB7|&B$Y$g7Y^)^%ycyHHt^08uYUEOY@1UWOuajWLcqiUoIDAf>Q{i_`@-|MVE{R*CtWfZ z!2>(sCh(}KNe@)>5oh63lBnw%+yqAB9mN{1-lD3tN&Ul60SN&>RTt1h`~Z9fGAIrC zKI75A+rT?pytC*Gp;Iy~b#NP$3P1|D>`y(T6oC8>f50Z_iAm-V=osz*e-*O?JO&qx z$(KO#;Tle0B|HFnNO4wbDfKRu%x3|zEG7glggTI|0FO%=rm}vPY;E9e;GI3*nI#9? z2W+CQ_2`1io|Ih5PpK0~+!L1_NxcGJfv2u3Pk00Rwk*j+_!aaJ=M*`M9LGq9q5isR+%4^@}o`?Qx z0Q~`{V#gPGr_4Kv^%gdczfM7m4m6(8{qSoYE2o-!xQ3ycr61hD+rT?Zyw@%{A|^lV zQg$NG2^B)xdu$|bEp9xv;|LPj3ZZJu zR!|b4`QQ=&qdU>S+rWF{cxRRz;DV$ZEtjNFg=0cc@)^!1jY2MUfyzLc+R*Yw7gIYz zTa0W1e!(4(Y+x(Uin6Y1Vx3~t6UB$6(7!ORXP$6J=ANO znsO={cpG?c6t9kXL*K8tr0DH|1*|(6x}NIc&}2>t@~#qr)#uAGp7$l{dG!6FAdG^ZkTpOHLFhGNnNDa5!FE?gIW3M@-&;BDZ& zalE>12ayO)N|vhxB1016#D%7bC^r(uYBS~sCF5vawTYvPDMY;=NkeiFKpbC!Uc#p| zi`q69z*#Qz!Tkmexd77MP-xg(89y;322=lwryrfyFBT37uQv9mb4#X|M*B0<|tmF^Kt#EQyscv!ks{VA7})GA+$(#VK2aFl_$ zFgzGahFO$&?UMlF!Px~CgFy%WVvHy~ZrZ@xzS_h6+*tultCa-;)8MupAU2h^ z120lTwSqmV$HerKs(jvh*DzegfDbc@9;LjgDFo_Q%0*OECeb>JkOlAv=NOc+aES!4 z7_N22Sw#=3G+Eh=k}(RGz$|36hKhySqJg)8_lEJ(zy8VJ0e$5Im(v@1Fq>@OdF#)@FWxKl*n21!ld`4+4 z6gzdQcy-B6-P(a8F=;`o8l=i6BQtv4nJ+COzD#inkIV90l(A{x{r`)1RMS#Iq&WXS z$E(K_D+&Vcsr-i219HEFFf^g5;LHh#T307mU#kR2T#Z64vU~n2$ML%CiB_i!5nRf5 zWCoEj+|Pi^%axi5-9%S6su|)Z6Ru^ITiaUBpFg&F^V$CXWv{=!_T zPT7S` zFTTiTisr}Kx{f});qv<1vu)j=pe2Q#2Sk!msqO5ky9W-=yBXuF(|R$*JqTjDkwOuV zXTQq*`GW4?)Cw+1hP9|#N>3-b9O>u?$%VhZJ}G!_ zykTCNXyA^dYS)UDuDujo^hD&zOiyZ}pj$7+)g6P*=svL!x?IxL*b9 z37@f!m(_yo-y6JkBKgmEK7O#P|H{SBa?mkZrfFH$lTA18X~mJAmC)0 z-v7hLj@^9^NAAF&+xB28^=4=1!$U(HLv^9@*Ce8IGTx!3OLsr@)Y$y_q);F~|M|RV z-2qT4XL-0bJACoPl2r%RY`okxZ*u-vm(vnR4T7AWc9F($YdQ8Inqoe#Pqx7s9-w;}Dff zB!h$GD_4h9)3#3TlK+DpQFo6t-tsmzOT>`{a`; zXlF6oW{VeR2$t|rBycYZjNJj&(oet>sKQMwz(v-S#_6CqEUw>-I8AX{(J*yZb1@4n zzZ1M;b9-LA@0p==TlmwC9puYj1_cKKAQd@`a(g?0X$_yKG&OA?(foXB@pmVVpZMJ8 z_Wtoxb}B7(BEYvSIr=aS#>YpRns#L}55V|>gC~h#7@ySRg)!ar$Rnq>YzZ~ZkADmw zy{?NTPnnkkV4uaVeo1+8%ERCo>iJ$O)_(;hGYcibVx=I~+g(8$wIlQU5=eBi>5T$=mFJ>(yMC4A81D zNu_|Te79OlwP{{~ zpmJ*u4A7P18*M$Rg{JZN>b1oMSUm!Q)G|29Q!PvmhVfBUBObbCY2vp#Z{4=dWvmKs zG?@iY6nqg@V*%6GzfM-JB!>=7D>=~IBEQu1;cuH>etF<8{(R{1$0c*$doLs?m&@n# z;ZllRGTod3ea#GjNu@Ibd=j;tO~v;1_rLnp^Q%^oN(BV?O~crz>pi}Im6>!Mc+pI# z3?{+di>}KZm%p=k!)t5ruUJX))?07x+$rWYbx^qwI5L@6)H=u{`!mgfGQ&vy{=|B` z*C9FAjd!1wIIw(``1^m5cYp8$^1%n>o_pl=_r5o^5A@OjR6Z{st5(6Vb z`>N-%N1EmovE&H{I3_3zwtbj$Rw}LZ%b?J$qy?kQrN^ovm}IF$6A1w^GkpE&Mr112AtWKfJD*6pyc7Z=l*7zQu_ej}JAND+?)%clxv%|u zBJd3kXOQ+Boy*QIj8<4KFPRAE=x8{3Mn+22Dh_$FVw)+;;Fer|5mw414MHxJr61jP z`+;Yk@qx2&luDrXa;enzQfc$KbKN7rEao{b=n^I-tKMtJ8&CAu8$Kga|Jt|i%;&d+ zO`Sf?SFHFiLYCZ`+2mg0ewfNsi*vQG01!1*pXHpI7GkRRy2u0x@I-LuQrQIJlXR4i@q_tK4uyiTe zxf46@7#z%8z5p}1do=e!d;2iR46qMc0Q)mGrt|{;IGAsaoL(3d!AA$pZc5_=gDt0) zOEsY~EwLlhS*cX3RS+B7w!tzKt<0W3{o7JoC;8dW*pVZD(9V`52uyj03wVGROU)H$ z-G@7mW;**PvR&1@?|W77(Wr1M6;0^AWg5DnG2LLgTIy39U&je-J8&E+KPr^NrEayA z3h+!#a-_+ES*A7`NiORQm@BJMTIfP3s3hLT#5BYXRC=Y7Jw9Hkj#q+-YN4wqY%z*D zI$!un^Y|D}8V{Hs%|dvq3XU>PeTbC66jrNlE*Ge*3-GR5t|aHAAli`xX<@7@ubD6m zI+RZP*u^WaU`O4)e=pc{P)f1|O}AaJ#VWHn-Bi1Fyg0RhYZH3%jFFN0^_RcI)(k@K zH=K_1x!|4-+xArf5QsEPlSbj}3>^P~eB@GJi)g@n7(fB-W^-F zI-uadeF8E2)vu5jAT1vS3-#>DUQ&^>6DG20fIR`cMKcvPbnznoZz&e5>HxtIJv|5i z?Aa=a&D(F2BS-Ga&_$q?ec^jPOm=v{FIK#Y(_M91vxA=NRbAH$AdZnedgZdl4J+W> zkc?4I69vnQ8R(>{`eRVuXfo0FD07{+>&kL$pT zYJB^4cyVailFA8iPE`2N=ep|)g(TqjyzSf10{xmguIzoX1@W1%UwFuM?LOQxJ2?_Hs* za+meQgbRZWAom;8FA3CZOtxXf&wgo zmWEhg&J1)f+@-gu%5dnaCG815N9Qj1Sei#!Mb~m%%bV>%Q}2ELaJC=JJ;7?R;qwJt zJnis-q6k{71mnFQk4^~RsoIijo~K)ekunoq$wW`9*^dje51(N-?d_4y&nMs*IFGFCd|bE7bZ(P znM{VcA9ZBT57@%>c%TKoX#~#d^&EV1IQH(9@&Hm~S@Kg^9=E;Yzugsgj-T#nO|Iu_BD_;CKI~w0ybz>7|$8V`Vd?Biv`)qrUCg;M2J_ zFw`;4aB*3w6f9fT1d6R#w992zYGsWzHz(TKn&!@JJ$u%_4d_4ZxA4X=91K6 zvbd!M|EG%+a_yh$7zj2KW+Ih@6Iu(}JA5=yQACt+E6mUW*F(R&+JDQwZ~x`Us@3B7 z@lSTV{S^1Ypd)soT3RoC@r$3%UoN(9UvuP*g~dX7qU6iGwr}x-V8nO*^Sz4?-uvLC zZ!VO+YAy#-I``23+;#NmlJV@d;>AFka}A}ayk`BO$2RTOw5EUh;df|dB3I1ki~q~M zmj_vPSLfY*d227PrCokp=E?L62fAUK-fS48Ol!Va$KYg<;2EG#Z_QPQjkhg zrocG3Qid{M%vNS6U=-mXu&@L|){Lalj7HMz)3fxxyzSn1_k8D^dtdiRnnl8Y04hNI4)(+LExM?zUT0PTiSCLPq`ChN>Uze zOfwk`E{27<4qAY_KE3&-BuzF#-L#=teCJpc$ zTn|0pi-IT&LY&HR%B~BvY*Lk3kBwK}kZJbNGtbo*mUz}dLwFk;EDsHp&z0_N)!ZdYabLz%vbAV$zo0`v)i9{T_Tq z;Rrf)VdiY5x}mI#8}8}OPjCE{r*_<&&%QqV@Qh(1gKV~%Ja3c%(Ry1p?f?Bhn%lWs znVBIuL0X7}aXj6lO z(uKFb>*T-st;lgG!37mtw<0g<{owB(Pm-;jE0^8xJJ1 z{cz)gYL~@yJ`(!KvY&YC+n>7a&YT17c6(vzzK-%+Rn_RrJX3xV`AVU5eqf#Nl=40% zUqhj1nuaV30F=)C!TZ9|G3E4W<-6Y{;1Kv*j~q;pTgW6bVI`}56PwoQ(*gvwiHUT2 znuLNxS866f(5g2MdhMI%ma~Ca&1!Q4>$q>2qoaXl3&~@uq;tRb-b_g5_=e-wm8ca2 zUg&q)9c0Bxm{hA}7)H5lyOq+ByWjNqYv1GpA0oXucJvMZ`)_u)7eITp>eOoP;Gk<5 zL7Hk{cwfF8epMV(#!O`%hD+7C<>1SZ(E~`9H|#Wlk}1 z>7RFg<+b@==jI5`;@_2EB%%E5sXeznw)b^C+s$vd|9%p-rls6crt+KPoPGE2oqOkR zq(Azx^7${)J+F8L5y@5ZfjGWxaVEADPDV6NpO90=AQoZz^7Jl_jop9Gy~j3PlfN1` z^??T{fk^wqF~2A&(QKups#0KG?+g4=ZR z!5Y)2@H1bweDQ#jjmdrqQT`ncyxbd>$`{`M!Nqs|CiNe``AvLs+-q(Z60Roo#7b%hcJ%dYKy~Yg9AG z^LmDw3=Otl_xk)i3{~)_*bk^~5cpvbDBPxU9J5|8uiSX!{r~cJ7yBivW;5A;;75Ub z<8Xb@NGlb)Qn7F+PKkg;Y|V0bDEr>Jo-(6SnQM>=wS1?Tqa@;ca<(E^OAUb`hswy< zl$I@&OiJC%S&8NuJ209sg;kuKye5@5uW3ftJa4|(SAx(i+d>pA*Q>}Hm$zHwU+l>^y$*X>^7o7CnO$||hd&}e0B{I$fASNaj*C;;=17C>J5K)h zkM`D2Dj)vvmhBrim6JxJ{C_uZZawxG^k`S7`-;|zZPDZ+UWY&krGe#iI)J|bxH=AY zDSFRk+E;$}KP2Dzj`HBosFS;ES3k6B0SqC5dY}2jKf3VF-^dOeaBH=lV`G!cXJ$8! zJa+B1h>8t0-Iw`;e$S@@PX_Hq#%ns3QL+rjq<%K!qib25fQ;sJXhcb#=in>m;KTEg zokaP;b^D@^el+iq!&@P;0k<$44|?jg-Ch!gx@G{}Km`rUC~}yWBj2f!VwmOV(IV#f zUS(kVu2;|f!M~58^q=^IIybk@^LEV5HR@{DGBd(RI-4lT-M{JP96PY*8r74H;Y#P! z((&PP9~n_13Z9zUdexnoJ?tu(h5SO8;7{w7@5qjBv)cy<( zSOKMGIF}Wh3n^Eni`gpB$@Zi2h7iST*qqdS@M!RnG=n~z$hL!Qe&YqQoP_Jy;SKo_ zIYf{@h$F@8aXDO-aufWk0j?TUC79mAp8NdyJREns!RY$q|LIQy+o3}9lTRx3y0U$H z-_=E3zuD}lae3GGzIx&9ztP;bgFF`Z$jFn0p;fW7#{D@tCraP*o_WVA|5M$V zpBnx8*K3WTy$iEutLsN$Y$8q~RWPFn#^Z!xh?j$K5aKw-rRZ&|%C-ObPn=iXcHmX7 zCwb4#N|hGED@RdBH%|S@f0_QZx6-R`xuy4k56s_tul?Z4$l)j5P`yd*ZHu}+uh;f_ zqLf)X&=#6@#dT6bEHEL!HNvbhtq^y-q?U&oiZ(RhT%fgzrvCcR@2eolTsLxm%{`Bk zfKhw)C{I64T*{OKi}BW0%gP)u+fc!4(T|rY-?M$oIdn+8p|jFF_^*F&d3;j&_{S~J z8=9Nl(&?^uoG6Oa!II4QsGNqAqz!F(-|hJmxMn@5gaA|%7mh63mE~)8Q!N{yePTj6 zbqZl8E|(A0CMM1nTL!Eijo62GOI_8wp-80X^BY1WoSiN%auS-N89H+Pl}dGGV!iUg z4=Us1^o55bvUR)ptV@tW+&}=bUk6fsKW`+g)#n0L#A1Dj%wb4LELcaYb(*2YLC&UP zF-YJY%uAIANp(`J4Ih*0YM-;xXTYbAHa6yOD_U0-&%?{aa>RHHcq1yD7~RIYPPN{L zYBU;>We5M;{|t{jL&bhvcicg-bK^#`97fnt2WiamR)5AcEoJINbMGzGLN)T1RK3?T zYWC?re1C2>fBU!4r%t7Ec-!@dH(aai35HG_pYyvz^GE!)$4gOAek%y5dk_Sn=LHDd zCRO&cOVPV7i^uiQ`pJV&yzZV90KNa}I7-57{>EE#v*AX2cK6-qhlkJK^A6l*xz6JF zNaH(SP1+r=-AyS0O|@>KFSTe<*ffAJG-3-pKje`pX)!0?Hyi$0(3+~LW4Z>wRH<6O z);aryfkrqqM3@c6gB)E^P9|2P-FEc^S*2^(fkFw4EO@stgY5Bv zXdDy#933S)Ns?AH=>PWbtgX-v`cPnC3L`|iLM2*V0xShjMQe8hSdQ+{Dx3jFp&4UA zaNFFecBS+U*PL%O6zMe;ml=l5W>3;9L@1mDPiF(rnPwstuA%CkdT;-#`Pv32Y3a| zP^UL-$!~t@DRJ9Re*W{(4}M_%^x@GHPdC)~=$qcqy><`bkjY80oS@lhEv`fXvTi%b zlzbwaTd4Ge#l_~pAO#}$;Kv`QXz+$Nkh1~BxU*JUilU!aYa5&G4Tla>hG!^}A4_|S zX8(BfR!F-Hz3@00)D)jDe3;wr%+4;Ie8=^4PAKtLzM{PEefh%0zyQ97rukfbWNLKl z-lZoD3OKnEtJH_&i9DT3Et*Mb2`{U#@Yrnn+W`dF^7*E`))S4*+VCc&>(fV& z%dzDIsy^*F>$)8ac2MH_XHN}7o11#tOOo%*`i-%mqXI|Nx*oD1cVX6MSnc*UV$sO0$8zY^qoc;1#BG7y}@VyYeCehMl@`rzSrt$6=QihmdISUJ9 z80B(w{z6}ooGi84%@(XnHK?==#v(=)mH_hRjS}z^b#`^$!8SCZZbD7|Z8rNq8h1pn zoKmSj{N>EfoDO>;@oKdUCiHr$RHgg++z&h5Zrrz={v;0fbJ%i1KV}SvFRkCJ<{BK; z0JyNAutTDIfR)#F^d!(Pte@-wW#u!NrwYsIh$-fw8!-o7-Jt2%=?z;}3jjFrpMF&N z>%Xo&xqtJqLrJ$|)T_g@Q{5YHR)nV_?D@sk@(Q`DlG_~^&gY=`U4(Jw=QFowed6Q6 z`VE3xly84qk^O~RZzZV!-aPZn*=oJ!I?mEEaEr7rs7=lnYk*W=81~%k<5jk(TfyNCF9rDK}o;!bT7tOOOMea;|F-(dzG%ZF&FrA9f zGUS=XhzBAjmKQGCtAS0xil(a8XZmTC^IcYbEg9!N*qK#fIx#d#x_S^GhgN0Jpk~9e8 zkjg0_$PT@YKmYNmd+sG?1g`GhO`a5|IeWJ6RfnQp(52JsilurUl@oA7(e@ytE;mM! zga80f;t`CB6{&#LJ#VwE9z&$!c^_QsJBthFE`(t$CvP-Bsgor7^YpoIITBP}*b+73 zMZYLKMEL6eVgLT67ww^P?NS>awj?V633v?{eR5*+3vYH2>I#q`2aTt@p=b1#)$_l* zacwwO{^Bo24j&$S?6H{pzuHQYO)ZdXDO@`UiBFu5WfsAWyW<=Bl!=ML^!;aNC(eFn z?xvf%Lqn^FfDFKH1Rp$Vb{0HXvEAWl9?>3t%J)^@@78Ly!-rd@>A!H=;Dz)qY?{oC zc4{iWXJrLvE`RG=BRh61?cAC4%OueFhaaYN2rAC*vt^h3*>T%fk*I0$YzmAT3NQRbu1z(pLCZKI<+oIaSU3ZOnUV=c3>@ea=hU~s^%xv{PAW-jx51Q@Q zql5lH)w3w*phkm?|)xLakqTvKWr?!t&v7~ zW}4yvVo4P3+c!w!R&@MA*2AtwzEgc@zKuQ~PP_jm2|1z*4gAeh583gOmD zfimu@E3uv`m6Ojl+pnfd0~F)6uT_5bGjg52zqogA&>${cpBx zrkH==fTmIlYmpns$D?=;*U2+xnqDzR{bH{U8Z}7?5=( zfMgNk2BHKQ#C_s&r^SAail@=8-HFV46lJ$TC9+%_P%ymyhBKe|U*|scnNqiV*VHq2 zKKuCi%AyKq46nmErM~-D%1{89&EY( z`n)K#VI%L=BK;+(6H{=eaL6LQD)}x?O!VM%xQ3kv9K?JW^coxi7ht)LTPc+Xs&vt5R_qCG(D>Pvm_ieC^#!A%*iI zBaYIUIlt8n1Ip6shn`fMO){!Zhf*CRFo?GU1IgIfxqIH!8yEnz4FY*Msn7o1uMAC# zhN%_hwcgw&C9rLi2iPUKef}Wjm9L`84Jm0fi<|(u!*XavfpZ{@mVMNGC+><*1K{oq z59cWzC#kYu5m7HX?|SE{FeN$K`7u_$Z+;WsHfizA{!+K&M`SrkZaHDxo1DC8_`+|4 z(K3tR@4F@cEplu2BpUsqoJI{N=_eXCok^qRK0vM~DS&)RQ&TL;FqjCwgr-(ZS?_LNhv?9|3>2j23Q zeAr@i^nAVk)#=4M);S|tfWt1Yo2ZrtHlI0jYS%7`u7Ex4yu67C#O)+a!#LtmzK}Z6 zrp82Em3&u|99|sYzP8uj*v$c(Wx!{V<sLttJlAi{g+T z0*1S;U9GwU1La%&`6JDR3t%Ah9ZvK7c^QGXmls>Ji_`!E2rOx~*J&I)Fu%PRX+w+! z;O81yI5BZ*&vl*Wo*kW@Ho&x@iO1LP`Tm|emHY2E&raQI`&(3Xx>8zMY4>fWpWnWW z*>i)HT9vId9%V43q~03UNIe%6fKu zGilh#lcQ?-D@n)mqo~u1{V0vd&TtRVT__4#>`{#gZ`g zej(Pv*oS+dFZc^l1BnLG>}Q?Uq~-GLZAFp|U%Lr@Gq^Ci`x}jhvTu}>%=7ebd}H4; z&rH4XjfuLt1_!|AkBya~?#OV}nLcQnIU&?**}(W5<*q{U}GpNL)GQaPw5- zHiKnSr-3pZUW?Z9NjdhuvlAP0Nj>;rek#9*n3HkE)v}CI$pT0QY{SRzUODweb2rrq zid_a?XIM-Lw$RL;bcwFn|I?*%EwLTaH$*>#pz(2vw{SzH((JBXvxq{2gAd5c!(V-7 z=KCgM1A_~A5Ys6x>P7S$pI5vxnJCB%MHoq~v6KhbX*B|DfwPm6wmeXf z_obdTB?#d!|5BpamZhc9rYv|ZBxS4{^UQfB`MLCuFHdit&fRxk(dvx{ zn$6buc#89g}-#LuAm(fC$+Yz zx2>@USJ(9Hp;zZNUqc6GN!d!aJMP%+wii+>kp@aE17=e$Td*Gh=G&9SZ>F&a%P9cA z5d`+a0-$?;*AFUQ^}4qnKm7C2&46W8AwUi@GefWqAO*k&wuIk+S4eEa@byE=y_*yh zxvghF?6e2U7ZNPkOu1YZ%hA@38eGwGGTEk%(|&>9wpE$Lk+o784oy=*4*8hi3m*kU zc?On)*g7{i8HTTHwc^>?r67>K2(1_(Fla6UY}U_j*q(WwcH;P5-L6wp{5VY_ir~1J zDzvs~SZ2Cs549>k{b^HG?lApVX{`k_^9W2D-uU`(Xju94Kc@<#8t;x;c5Aui2j(+J z6dV`iahnzHh zh3AdU&8>7g=Gn9ALl0$u4N?tXg~ZwT%IxIKR2qe`!C4vs&XirAMLNejRcav&8Tt_8 zk@_q{Pjz78)nX`a64hT_3W{!-8V_Aus9Kc>mmY}FrJ;=`6o&hWp)79g6qX!EmE%M4lF;Y7gF-@}I=uAp;I~ zFr2cDx3c5BTEj{54w#XJsZw~Ie(Wyh&-+X1QifHFeOtL-`o!upu^K-9_`v@Cw{^SY zK21q1@*+_xoe^H%pj|)in@zx_e<^=a%7a&ubIri5lPeX6Kq`dez!$t60gd z^B1KK1GAd%fLIYR_Bb0WW=F zq4C8pE^OJdc1mhEi*_`pwfQ;HPXHSYIhCGqss`79B*)@8S@1+D()3~yS{SPo9$dep zyLjliv-?dmE)WGG$4Iw1e&H-)5zr@&jNr8G*dg`yH<=6bTc*#{Pn~QpwLL|Z3Qc52 z(0L>~47B>|2A7lXnb{fTYhN3gxo~T{yRO$;34)b4zt&a=q_iTNrrDZ32m+a&mwo-~ zlk?NJTTwL*I$_`iA+MLM8Xovh?$n^sN5?VNKk}m|hIdUW;rPKL>B54qW)bOSu8$Jd zz!*c(cXT>;ZZZF^X`ED?R9OXDhUeAJog1HlkX>Ft3w4!e-&G>v^Z(J@3dy! z{_St?X}4)pjfT9Fv{-K7#ZGdpum|Xh0LncTZQbc7t{XP|$Y^Y_(&-Q2it!2cfX{cT&Pj0mw;D7MTJyvt!)1JLtd$(4Gx*M zV+PS38?|1myG(N%P&tBRj1f!(F1Y-$v4NqXYOPj9l1l26DOaR7(6wEEf8VvurcE7p zR!Oc{P;u|6rv{E51wOPluXA0engo?3=&p3S?d~dep?wS(t5vF&N|iEF>dHXXu9P&( z5EF?aK;?XxgAMpLT7HF*9}6i$Ae4I4a-V;ul(v?UF$7+ ze!JcfCJT z9VbJK3Dq=7sU)jvNT?90VL1v7-RZkW>`|=+3qLg1yU;@3*vsY@txg9IOHFHeSw(sW zFvh~w$(23pnfbE)Y zwOk#lRT}lNiXG2;Nuov(br^VEjHVnw=eG7-RjDk%TNAi}&T!YCG8cjhZma180U%f! zrQy&(x9fMio(v&yuf`Ay(RF8d7^YW&;{of~UnsJ1bQyX}N_OXoXPa4mrNt$S;#QiL zmzOJpx)s_0B;7di+Fifx>xQJ#BpJ)4AX6QzRR`;(0rC-M$uY{N#2g;vUF~ESqnQa$ z&17aAuU8^J0!7{BR=d5@MyibzQ80{Vf>-e^#=KQFjo87#!!QnlkTr%_1j+I~Va2HQlCNO(=Ah0ShQBWeV7D88Ldj-VCSjRK&B4%*!BnPNg&k)+V(zXuwRb)sSY! z6H)9hx6RH1?R$p3Sfd4PJOnrzNDQBVQxW(G`jFSaT3lDde^5%=Y0(WO--5ZSVpu=V zQQz~P_bC4ym+&-ztirI}Zns*p79PW3KtKsjmit~dFNkQof`ZHQJm2?mGd|*SV-k1b zJDXXqPjb%+U*hLVOg$cjJ6nA9_>u~VEWV4FaUOhDP;5S{&9NCDlqc8>7x22PFHMRX zMSS7a&1SPtspOh8D!~_ygttq7T^j9jwh~``Zs-@UW?bq@sIm~_fnW$;+UKy)Wv{ss zzU0ollEGKCiWpnVp~+RyE4I|96qk(H2rX54!{8j{X?Z-c!*|4D`D?QS-1J!ckM<1PWUGl#mGap?m zIZUksbDx`w`sH)sQNFZeSt8n@n>RqCosz@l4}LBJsP9{z-~ESfZS%10BBQivPu6i| z4$fIrLO0VRN1tuit{=C`wr0{?T-Xl6ZqICcde>78JvhB$l^wWzw@L>h+ca$*)|4nZ zyVa|wSG)wt6q17^NwS~7!?{W%eW96PEV6LiB^eyisVGw$ZOs@sTQ6LXQqTl zqsc3Lwf=Fcw7b#QU`QvSS+7`W+e+7pN-7Re+B!s*1F%8OT=2y%Rm*O@tQcDR=jV*F zW%R%eGEJNf^x_V>^{VNGMMIgBgc77?lNu+-kGG)e?BXoSugmxeL{Zv+uXE?TOIe^? z)~1@x-raF|rUX&9UZD*o*J?j}7W8r`&veh%+rHX%w6m6+ zt5MZpHYVXz%I*cP zxq_@Ry?T0iGB^ds;2~_YXsD@TIRG`BQ6TNmOQo2-Dc!=NGW$_Z0tMHzvV5n2HbPZ} zf0xfn_bXj#mUl=1Z)s73bT=%Q&7oSHB(${w_|G|j3srU<&>I2YCuE2~H;}VsvYsGs z$W-8S-_NdwUR{@cm5j&4D6BEaQQ7!yK|5^g1;#7tOfSfwRPi0EV{${B@?N_Hd02p6 zEbCMTUIh#3bZjc3WKoK|$>967EO9F(yqHR1z_AJ27?cHWUsK_o)rjgaRBbXNPMk?S z@ThVbXk4pSOA>5wW#*d3#*2_X(R|RhDth~7hXNRT#QQjeub7;Gik1A0s{cDVOpRanS7~~cUn31 zG&vciu*2X%rx`2Jm9*FeVR~76G~Un2@}f~DR>U(*c%x;yB{wdY?ZJASCbZaN>eP;8 z{{oFvOg)5WiRosI@&cW?j#NnJjd9cWuZmusf^r@)U^#F+t}C0Qwn&Oo2%6RJhZmhv zE&(xWf5inXf`<%4Lw9m-FR8CVeu#z{ltk&%%kR<{*;fUO&<@A#c^Ma=so%;SN77P$QF1AL?)w7X2~~wN zQbLf*XVK3Ag>hz3w9+_C(|(U^jmq~T=O@dnRLo}6>pK;G8CN$s0`P+2YL6NA0D~$P z1*rPT=g2F7QfLO^fCFOQu&s1&E^(IvcI{RO(%kyE3Tw zO!3aFRC2ei6&F`=DJ7NF<<;GRHT32&h+~ebsYSk#t056?8VD>YpwdtszopU~1m~I* zLZMNXsgSYgHt98`)8atYRI#kQhJ2Ou^74|(35<*~>aHt=AIMZ=7n$)cI=X z9Ck>sVVD{NHHoz3*J!r_4^WBxWR+eCU{pd&@SmC*2^R+R%%|xgjfY$4P7@h|#<4}! zxnKa;NT{{wg+Q^nU!)`EAn}CRfc?CJrAQ^~^7_o+C@<9rlohj4ik6@ug@UYrx%~>P zcp9m&Nu9L+`BF*ejfFglu{mlo%^}%XQ3jRf8dwZX;;Kr~DU$91C}Dfk*>fY0OriJ0 zN*M_w=LgZNtp~@<0RoYDZn1|7V4w$cSQD#3)bYTYaPa?=-E1fIWLV)v^>_*4FrzJ|1FPMA}u2mCC$YzVoRY#CTh9z&JrQl zy!}c7XT`HrOA*p|9T1ieDIm-uRbwEXaWu;7#+TP;PCA}f1Iu_IUc9GbtcsAWjqIQO zP*HQp1P&H%iMWrW$i@$Vv;1CqYHM|({{uUulw(WEuUFP?ugFBBKm{=-=C`_vkvX!c zk`(2XUDUA?1S$hQ3IjEjaRLlkwT+Y<1r^}Qo+)AKw*a$Wj9#g7YHKSq@`E^FnVpex zh;&*-lem7M^c_4aTBfQO(@TZ+EKhGq@mXGZb#8U5FV1A-zh&)JWHgY&dY{FaFk%gBvWrV7 z7x8rM$_Jhk^XO+0`|?>2ad<^xhi6YyMkGq1T!r8T5fOG<>!@>2cn%Rtz>i?VpF<)px$&5_$!}7QF(szk|7UBUk0gn-`(?VoP}*y`pvnLlm_b2_W}D z#*@b>s?inn5;pk-=#}8pUuAvS@}=bz*I3L zqH_QBqQQ+9wNzPc2P*~FNvPrG;~JjPVT7j|;}&@hCp&pyRP*ohE%!+IyEBeg^h+2< zLeU3LQw^=JrsO8HU()+adjA>drTrW!0#j|zOfxf!!-U_Y_shq{BV>z~y4uA^ybSiL z((S&?Fm->Ko71mVgz$WC1H{U3nfX#UpnjmBe5IJ0CCXU_;)b=0eMKrAa+PL4mHbgm zsm9FxCB46-_ZOx2$}Af0y zjjI^?$Xc!c*S@*zHVs5!*mH^FIK8P*2_Y_G2iAO^{5MsfC1uG=>2#JdT z3EJYciR~HAIsbU#mNtOA0!?J9D#RK8r<$2F=l@Pk+iq_pcXrnHyVbAZasIKGCcR1T zpX;@c9&OMj_4@Vq?d=>*kvP@SER^oat~~N^XRem^Fl~dDPG)TMx$*tY&>&^FXPVoC z&l?7L8dtsgc=v8eN#ShPoSZazJvSxghepcnZT)$6aB!yf5^G^&^UQW!kX6WS_v zuh?nPlBb5Glg45e-iJ9&zfUIY%8O=)ycxB^&bC|5e$ud5sOi+;PePxMkrmL;QLwll zr1fIIXeoc|q&MjuuGdQU3ZI8)!@}7JRfS7?Q}DBafyjknq=4e2rcUp8Z@JE@t=5G_ zn-_g82_}(xVs&oRSa^$$DS&}}iL#Zd>viDZ($mH5b**UIU0bshP|=$S=A$q)tu!PO zpEt${ub`9Oq<6SpdwSZ?lXZnfnw<`N+~vW1=V$v4wQ@o*$V?4RmhcL2m6cT#N{qzc zLr*ZabkPiE`@#jnga)OxL1N)SI;mh;gfkhU2|zU>tFc^&l8!)%nV{~#6KQL9vLRkK*=ONhaWj*ZOsNm!2(p>KUu-1%5Kvr^z!Vo~KrQ}}32 z%7uh>O1oex(Nz>if`Xd5aNEJYR9(BTLm9qpwOcyyp&gBGscYRqKOAd#3lv|vVr>-C zWW=O5=^d)qMxem2u9U3q{=vOGH-&p)!XyB&6ip5e#dO5P0xwQR)3jDDCbG0_XjISz z;nwn|lhjrTRlT(8(M*zckOnAT5GAo~IC=}{Y`qSkNP3grA$mhqdTT5H_HD6pq#hXo z6hff5juQ0|5J3hRx=r9uv3V?QTZY3bwwGpJv-6(o+K)zHklDnoDq2hUG4tFAMd~Sq z6`(!q^5?csPl++STw|o~*RL*{CcR1TK)qq+&!Yk=b zdI##YUC;CHEzt{*A`eGrLB~BmRV`Yd7^K&nyrkGr|F!3E=pIugWT+%CAt7^d`Ln^{T_e$0%8lw)6A$?5wG(wyK)!KYEoV zH)+t%qTpuLq&Mju{<3f09ACZP?cI*OidokfgX_o350l-STuv#BE^||keBFBK3qN`G zHovp(7pb0l4tjP;1(ew=nJ8j|<6WY3bU0`GK9aK^RUId`!4(ELX-1{H u>6c`QQqJ8_T9s0iQsQ8(Wab^@`3kuPA_p->w)Xt4Pkz>06 literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/open.bmp b/utils/wxPython/demo/bitmaps/open.bmp new file mode 100644 index 0000000000000000000000000000000000000000..1c38e97b59dac5b7dcb3d4ac14a31fe36d3fbc6e GIT binary patch literal 238 zcmZvVF%m){3`Ez_nP2KLES>QN_TFVHvE)eH08ZrCQ{W?L=aStGNg%iTOA8O|3{UU~ zcRHZbGxVQiiBQhVP*Szl@Yxs<8e?XVGfPPN!qmmh`zzRz%k)d~SOwQraPKkc3JUWb WyzyG%ebUB{{{0*7WXGE5t%V;V>_w>n literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/paste.bmp b/utils/wxPython/demo/bitmaps/paste.bmp new file mode 100644 index 0000000000000000000000000000000000000000..564f514e0df7225f0a7adbe8457b41af537813bd GIT binary patch literal 238 zcmZvVF%Ci@5Jbns$83OZ*I;# co}I%%@f6>ra3+S=gC69}eM%GII+SAI4J;x>B>(^b literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/smiles.bmp b/utils/wxPython/demo/bitmaps/smiles.bmp new file mode 100644 index 0000000000000000000000000000000000000000..39006fae82aa4e8c238c053f871538a8e2e5d8ac GIT binary patch literal 246 zcmYLCu?@p83{!w^29lo9JF@qk%swHfXe~I@Ll4T-B?CjrNh_P8M9S9u{92Di^bqbR z2D_zEl|N(0<)vYA!mPEEvPx^MiNj!CBcl>@LW=$@$O2#@cM+TfUaN!+Sgqi_!zIHD cVh+Fj@4d)`=7RlVy^omkdw@(qd!o?x0|m}&@c;k- literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/smiles.ico b/utils/wxPython/demo/bitmaps/smiles.ico new file mode 100644 index 0000000000000000000000000000000000000000..bb29c8edd7e66d24e5acde41c632ebb805b87891 GIT binary patch literal 766 zcmah{Ic~!+5FEt;0>gz}rHxAeBL12A1hx8wdNzED%9JWo7^Y`-NeVsyue8_f>~eJg z9k0GWK=StieA6GPJ@rKG@JUNy?X?7eH$ren%Md9gdKI$W$XOAUmmry!5-Dq8r!>Z? zBAzxzO$%UbpmkU$zHE6l(2OW(RYUe1r&$ z)Fj+QvAFmA=iIxDWqcdyW1sT2rPo)xMz%;3e5eO~rChb~`%^9A_*2Ywb{KLcM0*hm9^!K!#8l_#G{|IAsMso6S1XX#9x FeFHZg6}12W literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/test2.bmp b/utils/wxPython/demo/bitmaps/test2.bmp new file mode 100644 index 0000000000000000000000000000000000000000..3a6547321271e48f304443d3597480f9e1b6f448 GIT binary patch literal 12342 zcmd6tZ)jIl7{|Z8&NPZpvm&t63}q?^MbMaR&e(F8L9z)mBwvldfgngUL|pl1Y@uXt zBIsQ-7(tLA3>vIdCT#wBAwt523lfI2m7A{b^E$ zJm=hV&i&OjZ?8e=-**1p!2h-7|4(5RCH^ZvcNgyOJdjxMH3}3lmH02vN@COAO|@2y zg#zSSCF(*o?Rw;ksHiZ-gt7~Z0I-f=+q}KZl#4M(YRv&Nz;vMS5f!pYw#^gXl}u$- zh>%oqc?S3j=*1K;4vYfBz>r_Ceh3?ev2hfe#;HaJL%t~aQt*?!7xIJsW6>}kP{4K-cKquh5z#Esbc@kUi$6ZLt9QP=jfAO>d z3r&FY0x$Pr-FXi1xC@Kr4>VnH2*j+_b4{?K3D37!L z5zp<%nv;nxq<2A(e`(-dE2%CN;a^Jl#kr6W|D}h|av`M)qWmHFxjD?t;NCs?OWCTq zN7K__i9fZP5jk#iA(6UeMv_VOLHdi#D*Kp?!9y}+DAz!`~?D&Gq=(>eLsNAX5=PlLfhoH>IpzQFh2j#ome}7%@gc`l>8BFXEEH65VDDb z2hr9hoWK9hL{bbVVBbEpw1^HhuUwHtiW%gcXf5jR-HStq@Xa?8mVf?{TH->zEHhr} z!5bs&f=vGO;0r&oKl~7T_DGPKCvkql@7N(OR1|XY)8>2ciPvY(`utuOJjmKRWVR(y zWt3Pd;Z2An;n@q74$5nj@ZH@wf8NVF(*<1Pao3R11xbBPfO2jypPAL{ViuF$)&-nC zjn6*A=bz)d?_@X!@+ZM2BTxA8ac|U{QNU#?SK29EkQk_in-3r2@4xZKA2Ru{P~atR zs>_^7Zr{eGOZe$0{P2S~cB!B&d(NO_op}lTZ=b!QIxA^f#L83?LvnVJ3KmWw#%VKkA z2v@Iq(=wZ0R$B+O09~bR>Ai3Yh4{Vna5E%xyE1>eTAt3SQ~2~#965r%zJ!#hM8>NU zFiYdLrQ0rZ#72NH)sDEPeZHFWHlfU!_ucXO%WE2y%}qK%E%zaJ-0;+J1!EKu1jIaHH^ zSc{oeB)Y&2Li!L;<+zZiA*-YEf(yrwqrYF0+$<_ojY1}W<`9Tu>z$kpSv4z5FMRY7 z4j+yT2Tvy}{_KKgdRaPCN_-0_ZCuFTkkzy@8X9Co_`|_dcry6uyQQ-7LM~Navfk4t zhTnCcWmCEA!hr+wj=pk5?^8(6e_6;at6hTpvAJjQoGb%@lhW?pvcUNDSF4bRA1j*w z@BFv?@m!KoTwjk}yU@|W>FCMlPjG?obb;H4zP{@CxtDpig{P)G*-l(SL_%jTt7xdQ zHqh#}E@hd8>gwF?z&^^(AKA#XaW5HP!j<=xv8EFlG8&2*v5*D%OM@57cYz1jJbT|X z9$7!Q!_vf^mvg}~B=d()9&BCVFOWZupBv#-N9Dso&6HigIe6Cv8t{l<8KV4m@5=I+ zs{$T4a68Gub@jxAEOlmQZAF3S_;oL`&Q1&r*r!pmrDataL)QQ0wTFaSU5#Lj0d_WgSak-mxUwkiDt049wP6 zy|hAk^5^(11)qK7Jq^8oUGM{^D4IMje-_Vgks@;W<;x`yH#J;{PET6}4T}hsWw``X z_`M?(hw8c@&Y$Q)s3ChlU6wgt*Kd^*23sYWKPmW*`H}E5P?jMiyQGq|@wby!Kg=Hu zekOms3o;wB3RV^>79G@8?O(#d*Az<3pA3G&aFB8h7D-gT0yyb$=H&dzS(G`f#ZIaz z`$yWOW!k4c&$pA#ZxuKtf5;zk!3!zpNgkA$^G|QevM(~aqb2D$-80MmJ8jakJJwtF zZsl8&cYdCqKjea((y$40{_OE5O}`-p<(C6bo}bVrEz|zf?_l}Pln-H<`Qy4E;(}o4 ztCj~-k@Np*$UTqr!vSrMjlILy^zw#u`273{F1QRy{Qgqdg^JD9cy}lH!=E6l%Aa5_ z6y{8=_#*0FLgRk&2fm*wd}93FO=XS;ut^0+{E^6=!>QS!IYvl9a!;PNDq zl77FToEE+SKV3M;pMWhogWD7Z^LQqG9rYUxcj%AhfH={>Rq$5r}{rpekmLJQV{J>80u|Ph7js6FY C`uY<9 literal 0 HcmV?d00001 diff --git a/utils/wxPython/demo/bitmaps/tog1.bmp b/utils/wxPython/demo/bitmaps/tog1.bmp new file mode 100644 index 0000000000000000000000000000000000000000..75f6e7c4cb5d8733655a31cdedc5a6e8a2cdf611 GIT binary patch literal 238 zcmZ?rea8R+Wk5;;hy{R{ABY(lSb!u0Lj@2Y;e%kX0G!y*zyL%H`}adAAPHnL95`@* vp`oDxDDfYR82= self.min_length: break + n = n - 1 + if n: return string.lower(m.groups()[0]) + return "error" + + + +def stdprint(x): + print x + + + +class URLWordFetcher(WordFetcher): + def __init__(self, url): + self.OpenURL(url) + WordFetcher.__init__(self, "hangman_dict.txt") + + def logprint(self,x): + print x + + def RetrieveAsFile(self, host, path=''): + from httplib import HTTP + try: + h = HTTP(host) + except: + self.logprint("Failed to create HTTP connection to %s... is the network available?" % (host)) + return None + h.putrequest('GET',path) + h.putheader('Accept','text/html') + h.putheader('Accept','text/plain') + h.endheaders() + errcode, errmsg, headers = h.getreply() + if errcode != 200: + self.logprint("HTTP error code %d: %s" % (errcode, errmsg)) + return None + f = h.getfile() + return f + + def OpenURL(self,url): + from htmllib import HTMLParser + import formatter + self.url = url + m = re.match('http://([^/]+)(/\S*)\s*', url) + if m: + host = m.groups()[0] + path = m.groups()[1] + else: + m = re.match('http://(\S+)\s*', url) + if not m: + # Invalid URL + self.logprint("Invalid or unsupported URL: %s" % (url)) + return + host = m.groups()[0] + path = '' + f = self.RetrieveAsFile(host,path) + if not f: + self.logprint("Could not open %s" % (url)) + return + self.logprint("Receiving data...") + data = f.read() + tmp = open('hangman_dict.txt','w') + fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp)) + p = HTMLParser(fmt) + self.logprint("Parsing data...") + p.feed(data) + p.close() + tmp.close() + + + +class HangmanWnd(wxWindow): + def __init__(self, parent, id, pos=wxDefaultPosition, size=wxDefaultSize): + wxWindow.__init__(self, parent, id, pos, size) + self.SetBackgroundColour(wxNamedColour('white')) + if wxPlatform == '__WXGTK__': + self.font = wxFont(12, wxMODERN, wxNORMAL, wxNORMAL) + else: + self.font = wxFont(10, wxMODERN, wxNORMAL, wxNORMAL) + self.SetFocus() + + def StartGame(self, word): + self.word = word + self.guess = [] + self.tries = 0 + self.misses = 0 + self.Draw() + + def EndGame(self): + self.misses = 7; + self.guess = map(chr, range(ord('a'),ord('z')+1)) + self.Draw() + + def HandleKey(self, key): + self.message = "" + if self.guess.count(key): + self.message = 'Already guessed %s' % (key,) + return 0 + self.guess.append(key) + self.guess.sort() + self.tries = self.tries+1 + if not key in self.word: + self.misses = self.misses+1 + if self.misses == 7: + self.EndGame() + return 1 + has_won = 1 + for letter in self.word: + if not self.guess.count(letter): + has_won = 0 + break + if has_won: + self.Draw() + return 2 + self.Draw() + return 0 + + def Draw(self, dc = None): + if not dc: + dc = wxClientDC(self) + dc.SetFont(self.font) + dc.Clear() + (x,y) = self.GetSizeTuple() + x1 = x-200; y1 = 20 + for letter in self.word: + if self.guess.count(letter): + dc.DrawText(letter, x1, y1) + else: + dc.DrawText('.', x1, y1) + x1 = x1 + 10 + x1 = x-200 + dc.DrawText("tries %d misses %d" % (self.tries,self.misses),x1,50) + guesses = "" + for letter in self.guess: + guesses = guesses + letter + dc.DrawText("guessed:", x1, 70) + dc.DrawText(guesses[:13], x1+80, 70) + dc.DrawText(guesses[13:], x1+80, 90) + dc.SetUserScale(x/1000.0, y/1000.0) + self.DrawVictim(dc) + + def DrawVictim(self, dc): + dc.SetPen(wxPen(wxNamedColour('black'), 20)) + dc.DrawLines([(10, 980), (10,900), (700,900), (700,940), (720,940), + (720,980), (900,980)]) + dc.DrawLines([(100,900), (100, 100), (300,100)]) + dc.DrawLine(100,200,200,100) + if ( self.misses == 0 ): return + dc.SetPen(wxPen(wxNamedColour('blue'), 10)) + dc.DrawLine(300,100,300,200) + if ( self.misses == 1 ): return + dc.DrawEllipse(250,200,100,100) + if ( self.misses == 2 ): return + dc.DrawLine(300,300,300,600) + if ( self.misses == 3) : return + dc.DrawLine(300,300,250,550) + if ( self.misses == 4) : return + dc.DrawLine(300,300,350,550) + if ( self.misses == 5) : return + dc.DrawLine(300,600,350,850) + if ( self.misses == 6) : return + dc.DrawLine(300,600,250,850) + + def OnPaint(self, event): + dc = wxPaintDC(self) + self.Draw(dc) + + + +class HangmanDemo(HangmanWnd): + def __init__(self, wf, parent, id, pos, size): + HangmanWnd.__init__(self, parent, id, pos, size) + self.StartGame("dummy") + self.start_new = 1 + self.wf = wf + self.delay = 500 + self.timer = self.PlayTimer(self.MakeMove) + + def MakeMove(self): + self.timer.Stop() + if self.start_new: + self.StartGame(self.wf.Get()) + self.start_new = 0 + self.left = list('aaaabcdeeeeefghiiiiijklmnnnoooopqrssssttttuuuuvwxyz') + else: + key = self.left[int(random.random()*len(self.left))] + while self.left.count(key): self.left.remove(key) + self.start_new = self.HandleKey(key) + self.timer.Start(self.delay) + + def Stop(self): + self.timer.Stop() + + class PlayTimer(wxTimer): + def __init__(self,func): + wxTimer.__init__(self) + self.func = func + self.Start(1000) + + def Notify(self): + apply(self.func, ()) + + + +class HangmanDemoFrame(wxFrame): + def __init__(self, wf, parent, id, pos, size): + wxFrame.__init__(self, parent, id, "Hangman demo", pos, size) + self.demo = HangmanDemo(wf, self, -1, wxDefaultPosition, wxDefaultSize) + + def OnCloseWindow(self, event): + self.demo.timer.Stop() + self.Destroy() + + + +class AboutBox(wxDialog): + def __init__(self, parent,wf): + wxDialog.__init__(self, parent, -1, "About Hangman", wxDefaultPosition, wxSize(350,450)) + self.wnd = HangmanDemo(wf, self, -1, wxPoint(1,1), wxSize(350,150)) + self.static = wxStaticText(self, -1, __doc__, wxPoint(1,160), wxSize(350, 250)) + self.button = wxButton(self, 2001, "OK", wxPoint(150,420), wxSize(50,-1)) + EVT_BUTTON(self, 2001, self.OnOK) + + def OnOK(self, event): + self.wnd.Stop() + self.EndModal(wxID_OK) + + + +class MyFrame(wxFrame): + def __init__(self, parent, wf): + self.wf = wf + wxFrame.__init__(self, parent, -1, "hangman", wxDefaultPosition, wxSize(400,300)) + self.wnd = HangmanWnd(self, -1) + menu = wxMenu() + menu.Append(1001, "New") + menu.Append(1002, "End") + menu.AppendSeparator() + menu.Append(1003, "Reset") + menu.Append(1004, "Demo...") + menu.AppendSeparator() + menu.Append(1005, "Exit") + menubar = wxMenuBar() + menubar.Append(menu, "Game") + menu = wxMenu() + #menu.Append(1010, "Internal", "Use internal dictionary", TRUE) + menu.Append(1011, "ASCII File...") + urls = [ 'wxPython home', 'http://alldunn.com/wxPython/main.html', + 'slashdot.org', 'http://slashdot.org/', + 'cnn.com', 'http://cnn.com', + 'The New York Times', 'http://www.nytimes.com', + 'De Volkskrant', 'http://www.volkskrant.nl/frameless/25000006.html', + 'Gnu GPL', 'http://www.fsf.org/copyleft/gpl.html', + 'Bijbel: Genesis', 'http://www.coas.com/bijbel/gn1.htm'] + urlmenu = wxMenu() + for item in range(0,len(urls),2): + urlmenu.Append(1020+item/2, urls[item], urls[item+1]) + urlmenu.Append(1080, 'Other...', 'Enter an URL') + menu.AppendMenu(1012, 'URL', urlmenu, 'Use a webpage') + menu.Append(1013, 'Dump', 'Write contents to stdout') + menubar.Append(menu, "Dictionary") + self.urls = urls + self.urloffset = 1020 + menu = wxMenu() + menu.Append(1090, "About...") + menubar.Append(menu, "Help") + self.SetMenuBar(menubar) + self.CreateStatusBar(2) + EVT_MENU(self, 1001, self.OnGameNew) + EVT_MENU(self, 1002, self.OnGameEnd) + EVT_MENU(self, 1003, self.OnGameReset) + EVT_MENU(self, 1004, self.OnGameDemo) + EVT_MENU(self, 1005, self.OnWindowClose) + EVT_MENU(self, 1011, self.OnDictFile) + EVT_MENU_RANGE(self, 1020, 1020+len(urls)/2, self.OnDictURL) + EVT_MENU(self, 1080, self.OnDictURLSel) + EVT_MENU(self, 1013, self.OnDictDump) + EVT_MENU(self, 1090, self.OnHelpAbout) + EVT_CHAR(self.wnd, self.OnChar) + self.OnGameReset() + + def OnGameNew(self, event): + word = self.wf.Get() + self.in_progress = 1 + self.SetStatusText("",0) + self.wnd.StartGame(word) + + def OnGameEnd(self, event): + self.UpdateAverages(0) + self.in_progress = 0 + self.SetStatusText("",0) + self.wnd.EndGame() + + def OnGameReset(self, event=None): + self.played = 0 + self.won = 0 + self.history = [] + self.average = 0.0 + self.OnGameNew(None) + + def OnGameDemo(self, event): + frame = HangmanDemoFrame(self.wf, self, -1, wxDefaultPosition, self.GetSize()) + frame.Show(TRUE) + + def OnDictFile(self, event): + fd = wxFileDialog(self) + if (self.wf.filename): + fd.SetFilename(self.wf.filename) + if fd.ShowModal() == wxID_OK: + file = fd.GetPath() + self.wf = WordFetcher(file) + + def OnDictURL(self, event): + item = (event.GetId() - self.urloffset)*2 + print "Trying to open %s at %s" % (self.urls[item], self.urls[item+1]) + self.wf = URLWordFetcher(self.urls[item+1]) + + def OnDictURLSel(self, event): + msg = wxTextEntryDialog(self, "Enter the URL of the dictionary document", "Enter URL") + if msg.ShowModal() == wxID_OK: + url = msg.GetValue() + self.wf = URLWordFetcher(url) + def OnDictDump(self, event): + print self.wf.words + + def OnHelpAbout(self, event): + about = AboutBox(self, self.wf) + about.ShowModal() + about.wnd.Stop() # that damn timer won't stop! + + def UpdateAverages(self, has_won): + if has_won: + self.won = self.won + 1 + self.played = self.played+1 + self.history.append(self.wnd.misses) # ugly + total = 0.0 + for m in self.history: + total = total + m + self.average = float(total/len(self.history)) + + def OnChar(self, event): + if not self.in_progress: + self.OnGameNew(None) + return + key = event.KeyCode(); + if key >= ord('A') and key <= ord('Z'): + key = key + ord('a') - ord('A') + key = chr(key) + if key < 'a' or key > 'z': + event.Skip() + return + res = self.wnd.HandleKey(key) + if res == 0: + self.SetStatusText(self.wnd.message) + elif res == 1: + self.UpdateAverages(0) + self.SetStatusText("Too bad, you're dead!",0) + self.in_progress = 0 + elif res == 2: + self.in_progress = 0 + self.UpdateAverages(1) + self.SetStatusText("Congratulations!",0) + if self.played: + percent = (100.*self.won)/self.played + else: + percent = 0.0 + self.SetStatusText("p %d, w %d (%g %%), av %g" % (self.played,self.won, percent, self.average),1) + + def OnWindowClose(self, event): + self.Destroy() + + + +class MyApp(wxApp): + def OnInit(self): + if wxPlatform == '__WXGTK__': + defaultfile = "/usr/share/games/hangman-words" + elif wxPlatform == '__WXMSW__': + defaultfile = "c:\\windows\\hardware.txt" + else: + defaultfile = "" + wf = WordFetcher(defaultfile) + frame = MyFrame(NULL, wf) + self.SetTopWindow(frame) + frame.Show(TRUE) + return TRUE + + + +if __name__ == '__main__': + app = MyApp(0) + app.MainLoop() + + +#---------------------------------------------------------------------- + +overview = __doc__ + + +def runTest(frame, nb, log): + if wxPlatform == '__WXGTK__' or wxPlatform == '__WXMOTIF__': + defaultfile = "/usr/share/games/hangman-words" + elif wxPlatform == '__WXMSW__': + defaultfile = "c:\\windows\\hardware.txt" + else: + defaultfile = "" + wf = WordFetcher(defaultfile) + win = MyFrame(frame, wf) + frame.otherWin = win + win.Show(true) + + +#---------------------------------------------------------------------- + + + + diff --git a/utils/wxPython/demo/pyTree.py b/utils/wxPython/demo/pyTree.py new file mode 100644 index 0000000000..47283527f1 --- /dev/null +++ b/utils/wxPython/demo/pyTree.py @@ -0,0 +1,211 @@ +""" +Hello, and welcome to this test of the wxTreeItemData +class. + +The wxTreeItemData class can be used to associate a python +object with a wxTreeCtrl item. In this sample, its use is +demonstrated via a tree control that shows the contents of a +python namespace according to the standard dir() +command. Every item in the tree has its label taken from the +dir() output, and 'behind it' a reference to the python +object is stored in a wxTreeItemData object. + +As you may have guessed by now, this sample automatically +displays '__doc__' strings if the selected python object +happens to have one. Please expand the pyTree object to +learn more about the implementation. + +Version 1.0, April 4 1999. +Harm van der Heijden (H.v.d.Heijden@phys.tue.nl) + +P.S. Check out the string module. It's imported in this +sample not because it's used, but because it's so +beautifully documented... +""" + +from wxPython import wx +import string # Don't use it, but it's fun expanding :-) + +#---------------------------------------------------------------------- + +def _getindent(line): + """Returns the indentation level of the given line.""" + indent = 0 + for c in line: + if c == ' ': indent = indent + 1 + elif c == '\t': indent = indent + 8 + else: break + return indent + +def _sourcefinder(func): + """Given a func_code object, this function tries to find and return + the python source code of the function.""" + try: + f = open(func.co_filename,"r") + except: + return "(could not open file %s)" % (func.co_filename,) + + for i in range(func.co_firstlineno): + line = f.readline() + ind = _getindent(line) + msg = "" + while line: + msg = msg + line + line = f.readline() + # the following should be <= ind, but then we get + # confused by multiline docstrings. Using == works most of + # the time... but not always! + if _getindent(line) == ind: break + return msg + +#---------------------------------------------------------------------- + +class pyTree(wx.wxTreeCtrl): + """ + This wxTreeCtrl derivative displays a tree view of a Python namespace. + Anything from which the dir() command returns a non-empty list is a branch + in this tree. + """ + + def __init__(self, parent, id, root): + """ + Initialize function; because we insert branches into the tree + as needed, we use the ITEM_EXPANDING event handler. The + ITEM_COLLAPSED handler removes the stuff afterwards. The + SEL_CHANGED handler attempts to display interesting + information about the selected object. + """ + wx.wxTreeCtrl.__init__(self, parent, id) + self.root = self.AddRoot(str(root), -1, -1, wx.wxTreeItemData(root)) + if dir(root): + self.SetItemHasChildren(self.root, wx.TRUE) + wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding) + wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed) + wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged) + self.output = None + + + def SetOutput(self, output): + """ + Set output function (accepts single string). Used to display string + representation of the selected object by OnSelChanged. + """ + self.output = output + + + def OnItemExpanding(self,event): + """ + The real workhorse of this class. First we retrieve the object + (parent) belonging to the branch that is to be expanded. This + is done by calling GetPyData(parent), which is a short-cut for + GetPyItemData(parent).Get(). + + Then we get the dir() list of that object. For each item in + this list, a tree item is created with associated + wxTreeItemData referencing the child object. We get this + object using child = getattr(parent, item). + + Finally, we check wether the child returns a non-empty dir() + list. If so, it is labeled as 'having children', so that it + may be expanded. When it actually is expanded, this function + will again figure out what the offspring is. + """ + item = event.GetItem() + obj = self.GetPyData( item ) + lst = dir(obj) + for key in lst: + new_obj = getattr(obj,key) + new_item = self.AppendItem( item, key, -1, -1, + wx.wxTreeItemData(new_obj) ) + if dir(new_obj): + self.SetItemHasChildren(new_item, wx.TRUE) + + def OnItemCollapsed(self, event): + """ + We need to remove all children here, otherwise we'll see all + that old rubbish again after the next expansion. + """ + item = event.GetItem() + self.DeleteChildren(item) + + def OnSelChanged(self, event): + """ + If an output function is defined, we try to print some + informative, interesting and thought-provoking stuff to it. + If it has a __doc__ string, we print it. If it's a function or + unbound class method, we attempt to find the python source. + """ + if not self.output: + return + obj = self.GetPyData( event.GetItem() ) + msg = str(obj) + if hasattr(obj, '__doc__'): + msg = msg+"\n\nDocumentation string:\n\n%s" % ( getattr(obj, '__doc__'),) + # Is it a function? + func = None + if hasattr(obj, "func_code"): # normal function + func = getattr(obj, "func_code") + elif hasattr(obj, "im_func"): # unbound class method + func = getattr(getattr(obj, "im_func"), "func_code") + if func: # if we found one, let's try to print the source + msg = msg+"\n\nFunction source:\n\n" + _sourcefinder(func) + + apply(self.output, (msg,)) + +#---------------------------------------------------------------------- + +overview = __doc__ + +def runTest(frame, nb, log): + """ + This method is used by the wxPython Demo Framework for integrating + this demo with the rest. + """ + thisModule = __import__(__name__, globals()) + win = wx.wxFrame(frame, -1, "PyTreeItemData Test") + split = wx.wxSplitterWindow(win, -1) + tree = pyTree(split, -1, thisModule) + text = wx.wxTextCtrl(split, -1, "", wx.wxDefaultPosition, + wx.wxDefaultSize, wx.wxTE_MULTILINE) + split.SplitVertically(tree, text, 200) + tree.SetOutput(text.SetValue) + tree.SelectItem(tree.root) + win.SetSize(wx.wxSize(800,500)) + frame.otherWin = win + win.Show(1) + + + +#---------------------------------------------------------------------- +if __name__ == '__main__': + + class MyFrame(wx.wxFrame): + """Very standard Frame class. Nothing special here!""" + + def __init__(self): + """Make a splitter window; left a tree, right a textctrl. Wow.""" + import __main__ + wx.wxFrame.__init__(self, wx.NULL, -1, "PyTreeItemData Test", + wx.wxDefaultPosition, wx.wxSize(800,500)) + split = wx.wxSplitterWindow(self, -1) + tree = pyTree(split, -1, __main__) + text = wx.wxTextCtrl(split, -1, "", wx.wxDefaultPosition, + wx.wxDefaultSize, wx.wxTE_MULTILINE) + split.SplitVertically(tree, text, 200) + tree.SetOutput(text.SetValue) + tree.SelectItem(tree.root) + + class MyApp(wx.wxApp): + """This class is even less interesting than MyFrame.""" + + def OnInit(self): + """OnInit. Boring, boring, boring!""" + frame = MyFrame() + frame.Show(wx.TRUE) + self.SetTopWindow(frame) + return wx.TRUE + + app = MyApp(0) + app.MainLoop() + + diff --git a/utils/wxPython/demo/wxButton.py b/utils/wxPython/demo/wxButton.py new file mode 100644 index 0000000000..2ea79bdca7 --- /dev/null +++ b/utils/wxPython/demo/wxButton.py @@ -0,0 +1,47 @@ + +from wxPython.wx import * + +#---------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + self.log = log + + wxButton(self, 10, "Hello", wxPoint(20, 20)).SetDefault() + EVT_BUTTON(self, 10, self.OnClick) + + wxButton(self, 20, "HELLO AGAIN!", wxPoint(20, 60), wxSize(90, 45)) + EVT_BUTTON(self, 20, self.OnClick) + + bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP) + wxBitmapButton(self, 30, bmp, wxPoint(140, 20), + wxSize(bmp.GetWidth()+10, bmp.GetHeight()+10)) + EVT_BUTTON(self, 30, self.OnClick) + + + def OnClick(self, event): + self.log.WriteText("Click! (%d)\n" % event.GetId()) + + +#---------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestPanel(nb, log) + return win + +#---------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" + + diff --git a/utils/wxPython/demo/wxCheckBox.py b/utils/wxPython/demo/wxCheckBox.py new file mode 100644 index 0000000000..8f1f7d5d78 --- /dev/null +++ b/utils/wxPython/demo/wxCheckBox.py @@ -0,0 +1,80 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestCheckBox(wxPanel): + def __init__(self, parent, log): + self.log = log + wxPanel.__init__(self, parent, -1) + + wxStaticText(self, -1, "This example uses the wxCheckBox control.", + wxPoint(10, 10)) + + cID = NewId() + cb1 = wxCheckBox(self, cID, " Apples", wxPoint(65, 40), wxSize(150, 20), wxNO_BORDER) + cb2 = wxCheckBox(self, cID+1, " Oranges", wxPoint(65, 60), wxSize(150, 20), wxNO_BORDER) + cb2.SetValue(true) + cb3 = wxCheckBox(self, cID+2, " Pears", wxPoint(65, 80), wxSize(150, 20), wxNO_BORDER) + + EVT_CHECKBOX(self, cID, self.EvtCheckBox) + EVT_CHECKBOX(self, cID+1, self.EvtCheckBox) + EVT_CHECKBOX(self, cID+2, self.EvtCheckBox) + + + def EvtCheckBox(self, event): + self.log.WriteText('EvtCheckBox: %d\n' % event.Checked()) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestCheckBox(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + +overview = """\ +A checkbox is a labelled box which is either on (checkmark is visible) or off (no checkmark). + +wxCheckBox() +----------------------- + +Default constructor. + +wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& val, const wxString& name = "checkBox") + +Constructor, creating and showing a checkbox. + +Parameters +------------------- + +parent = Parent window. Must not be NULL. + +id = Checkbox identifier. A value of -1 indicates a default value. + +label = Text to be displayed next to the checkbox. + +pos = Checkbox position. If the position (-1, -1) is specified then a default position is chosen. + +size = Checkbox size. If the default size (-1, -1) is specified then a default size is chosen. + +style = Window style. See wxCheckBox. + +validator = Window validator. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxCheckListBox.py b/utils/wxPython/demo/wxCheckListBox.py new file mode 100644 index 0000000000..4727459b0c --- /dev/null +++ b/utils/wxPython/demo/wxCheckListBox.py @@ -0,0 +1,53 @@ + +from wxPython.wx import * + +#---------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + self.log = log + + sampleList = ['zero', 'one', 'two', 'three', 'four', 'five', + 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', + 'twelve', 'thirteen', 'fourteen'] + + wxStaticText(self, -1, "This example uses the wxCheckListBox control.", + wxPoint(45, 15)) + + lb = wxCheckListBox(self, 60, wxPoint(80, 50), wxSize(80, 120), + sampleList) + EVT_LISTBOX(self, 60, self.EvtListBox) + EVT_LISTBOX_DCLICK(self, 60, self.EvtListBoxDClick) + lb.SetSelection(0) + + + def EvtListBox(self, event): + self.log.WriteText('EvtListBox: %s\n' % event.GetString()) + + def EvtListBoxDClick(self, event): + self.log.WriteText('EvtListBoxDClick:\n') + + + +#---------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestPanel(nb, log) + return win + +#---------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" + + diff --git a/utils/wxPython/demo/wxChoice.py b/utils/wxPython/demo/wxChoice.py new file mode 100644 index 0000000000..55ddbb5ebf --- /dev/null +++ b/utils/wxPython/demo/wxChoice.py @@ -0,0 +1,76 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestChoice(wxPanel): + def __init__(self, parent, log): + self.log = log + wxPanel.__init__(self, parent, -1) + + sampleList = ['zero', 'one', 'two', 'three', 'four', 'five', + 'six', 'seven', 'eight'] + + wxStaticText(self, -1, "This example uses the wxChoice control.", + wxPoint(15, 10)) + + wxStaticText(self, -1, "Select one:", wxPoint(15, 50), wxSize(75, 20)) + wxChoice(self, 40, wxPoint(80, 50), wxSize(95, 20), #wxDefaultSize, + sampleList) + EVT_CHOICE(self, 40, self.EvtChoice) + + def EvtChoice(self, event): + self.log.WriteText('EvtChoice: %s\n' % event.GetString()) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestChoice(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + +overview = """\ +A choice item is used to select one of a list of strings. Unlike a listbox, only the selection is visible until the user pulls down the menu of choices. + +wxChoice() +------------------- + +Default constructor. + +wxChoice(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, int n, const wxString choices[], long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "choice") + +Constructor, creating and showing a choice. + +Parameters +------------------- + +parent = Parent window. Must not be NULL. + +id = Window identifier. A value of -1 indicates a default value. + +pos = Window position. + +size = Window size. If the default size (-1, -1) is specified then the choice is sized appropriately. + +n = Number of strings with which to initialise the choice control. + +choices = An array of strings with which to initialise the choice control. + +style = Window style. See wxChoice. + +validator = Window validator. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxColourDialog.py b/utils/wxPython/demo/wxColourDialog.py new file mode 100644 index 0000000000..1f06f5cb28 --- /dev/null +++ b/utils/wxPython/demo/wxColourDialog.py @@ -0,0 +1,38 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + data = wxColourData() + data.SetChooseFull(true) + dlg = wxColourDialog(frame, data) + if dlg.ShowModal() == wxID_OK: + data = dlg.GetColourData() + log.WriteText('You selected: %s\n' % str(data.GetColour().Get())) + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + +overview = """\ +This class represents the colour chooser dialog. + +wxColourDialog() +------------------------------ + +wxColourDialog(wxWindow* parent, wxColourData* data = NULL) + +Constructor. Pass a parent window, and optionally a pointer to a block of colour data, which will be copied to the colour dialog's colour data. + +""" diff --git a/utils/wxPython/demo/wxComboBox.py b/utils/wxPython/demo/wxComboBox.py new file mode 100644 index 0000000000..4415d2f64e --- /dev/null +++ b/utils/wxPython/demo/wxComboBox.py @@ -0,0 +1,79 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestComboBox(wxPanel): + def __init__(self, parent, log): + self.log = log + wxPanel.__init__(self, parent, -1) + + sampleList = ['zero', 'one', 'two', 'three', 'four', 'five', + 'six', 'seven', 'eight'] + + wxStaticText(self, -1, "This example uses the wxComboBox control.", + wxPoint(8, 10)) + + wxStaticText(self, -1, "Select one:", wxPoint(15, 50), wxSize(75, 18)) + wxComboBox(self, 50, "default value", wxPoint(80, 50), wxSize(95, 20), + sampleList, wxCB_DROPDOWN) + EVT_COMBOBOX(self, 50, self.EvtComboBox) + + + def EvtComboBox(self, event): + self.log.WriteText('EvtComboBox: %s\n' % event.GetString()) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestComboBox(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + +overview = """\ +A combobox is like a combination of an edit control and a listbox. It can be displayed as static list with editable or read-only text field; or a drop-down list with text field; or a drop-down list without a text field. + +A combobox permits a single selection only. Combobox items are numbered from zero. + +wxComboBox() +----------------------- + +Default constructor. + +wxComboBox(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, int n, const wxString choices[], long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "comboBox") + +Constructor, creating and showing a combobox. + +Parameters +------------------- + +parent = Parent window. Must not be NULL. + +id = Window identifier. A value of -1 indicates a default value. + +pos = Window position. + +size = Window size. If the default size (-1, -1) is specified then the window is sized appropriately. + +n = Number of strings with which to initialise the control. + +choices = An array of strings with which to initialise the control. + +style = Window style. See wxComboBox. + +validator = Window validator. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxDialog.py b/utils/wxPython/demo/wxDialog.py new file mode 100644 index 0000000000..a22a528248 --- /dev/null +++ b/utils/wxPython/demo/wxDialog.py @@ -0,0 +1,33 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = wxDialog(frame, -1, "This is a wxDialog", wxDefaultPosition, wxSize(350, 200)) + + wxStaticText(win, -1, "This is a wxDialog", wxPoint(20, 20)) + wxButton(win, wxID_OK, " OK ", wxPoint(75, 120), wxDefaultSize).SetDefault() + wxButton(win, wxID_CANCEL, " Cancel ", wxPoint(150, 120), wxDefaultSize) + + val = win.ShowModal() + if val == wxID_OK: + log.WriteText("You pressed OK\n") + else: + log.WriteText("You pressed Cancel\n") + + + +#--------------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxDirDialog.py b/utils/wxPython/demo/wxDirDialog.py new file mode 100644 index 0000000000..1e40bf2bb1 --- /dev/null +++ b/utils/wxPython/demo/wxDirDialog.py @@ -0,0 +1,53 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + dlg = wxDirDialog(frame) + if dlg.ShowModal() == wxID_OK: + log.WriteText('You selected: %s\n' % dlg.GetPath()) + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + + + + +overview = """\ +This class represents the directory chooser dialog. + +wxDirDialog() +------------------------ + +wxDirDialog(wxWindow* parent, const wxString& message = "Choose a directory", const wxString& defaultPath = "", long style = 0, const wxPoint& pos = wxDefaultPosition) + +Constructor. Use wxDirDialog::ShowModal to show the dialog. + +Parameters +------------------- + +parent = Parent window. + +message = Message to show on the dialog. + +defaultPath = The default path, or the empty string. + +style = A dialog style, currently unused. + +pos = Dialog position. +""" diff --git a/utils/wxPython/demo/wxFileDialog.py b/utils/wxPython/demo/wxFileDialog.py new file mode 100644 index 0000000000..0287f4ccd5 --- /dev/null +++ b/utils/wxPython/demo/wxFileDialog.py @@ -0,0 +1,62 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + dlg = wxFileDialog(frame, "Choose a file", ".", "", "*.*", wxOPEN) + if dlg.ShowModal() == wxID_OK: + log.WriteText('You selected: %s\n' % dlg.GetPath()) + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + +overview = """\ +This class represents the file chooser dialog. + +wxFileDialog() +---------------------------- + +wxFileDialog(wxWindow* parent, const wxString& message = "Choose a file", const wxString& defaultDir = "" +, const wxString& defaultFile = "", const wxString& wildcard = "*.*", long style = 0, const wxPoint& pos = wxDefaultPosition) + +Constructor. Use wxFileDialog::ShowModal to show the dialog. + +Parameters +------------------- + +parent = Parent window. + +message = Message to show on the dialog. + +defaultDir = The default directory, or the empty string. + +defaultFile = The default filename, or the empty string. + +wildcard = A wildcard, such as "*.*". + +style = A dialog style. A bitlist of: + +wxOPEN This is an open dialog (Windows only). + +wxSAVE This is a save dialog (Windows only). + +wxHIDE_READONLY Hide read-only files (Windows only). + +wxOVERWRITE_PROMPT Prompt for a conformation if a file will be overridden (Windows only). + +pos = Dialog position. +""" diff --git a/utils/wxPython/demo/wxFontDialog.py b/utils/wxPython/demo/wxFontDialog.py new file mode 100644 index 0000000000..ec1caa73ff --- /dev/null +++ b/utils/wxPython/demo/wxFontDialog.py @@ -0,0 +1,39 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + dlg = wxFontDialog(frame) + if dlg.ShowModal() == wxID_OK: + data = dlg.GetFontData() + font = data.GetChosenFont() + log.WriteText('You selected: "%s", %d points, color %s\n' % + (font.GetFaceName(), font.GetPointSize(), + data.GetColour().Get())) + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + +overview = """\ +This class represents the font chooser dialog. + +wxFontDialog() +---------------------------- + +wxFontDialog(wxWindow* parent, wxFontData* data = NULL) + +Constructor. Pass a parent window, and optionally a pointer to a block of font data, which will be copied to the font dialog's font data. +""" diff --git a/utils/wxPython/demo/wxFrame.py b/utils/wxPython/demo/wxFrame.py new file mode 100644 index 0000000000..e0fc080954 --- /dev/null +++ b/utils/wxPython/demo/wxFrame.py @@ -0,0 +1,41 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class MyFrame(wxFrame): + def __init__(self, parent, ID, title, pos, size): + wxFrame.__init__(self, parent, ID, title, pos, size) + panel = wxPanel(self, -1) + + button = wxButton(panel, 1003, "Close Me") + button.SetPosition(wxPoint(15, 15)) + EVT_BUTTON(self, 1003, self.OnCloseMe) + + def OnCloseMe(self, event): + self.Close(true) + + def OnCloseWindow(self, event): + self.Destroy() + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = MyFrame(frame, -1, "This is a wxFrame", wxDefaultPosition, wxSize(350, 200)) + frame.otherWin = win + win.Show(true) + + +#--------------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxGLCanvas.py b/utils/wxPython/demo/wxGLCanvas.py new file mode 100644 index 0000000000..4290f92767 --- /dev/null +++ b/utils/wxPython/demo/wxGLCanvas.py @@ -0,0 +1,153 @@ + +from wxPython.wx import * +try: + from wxPython.glcanvas import * + haveGLCanvas = true +except ImportError: + haveGLCanvas = false + +#---------------------------------------------------------------------- + +if not haveGLCanvas: + def runTest(frame, nb, log): + dlg = wxMessageDialog(frame, 'The wxGLCanvas has not been included with this build of wxPython!', + 'Sorry', wxOK | wxICON_INFORMATION) + dlg.ShowModal() + dlg.Destroy() + +else: + + + def runTest(frame, nb, log): + win = TestGLCanvas(nb) + return win + + + + class TestGLCanvas(wxGLCanvas): + def __init__(self, parent): + wxGLCanvas.__init__(self, parent, -1) + EVT_ERASE_BACKGROUND(self, self.OnEraseBackground) + self.init = false + + def OnEraseBackground(self, event): + pass # Do nothing, to avoid flashing. + + + def OnSize(self, event): + size = self.GetClientSize() + if self.GetContext() != 'NULL': + self.SetCurrent() + glViewport(0, 0, size.width, size.height) + + + def OnPaint(self, event): + dc = wxPaintDC(self) + + ctx = self.GetContext() + if ctx == "NULL": return + + self.SetCurrent() + + + if not self.init: + self.InitGL() + self.init = true + + # clear color and depth buffers + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + # draw six faces of a cube + glBegin(GL_QUADS) + glNormal3f( 0.0, 0.0, 1.0) + glVertex3f( 0.5, 0.5, 0.5) + glVertex3f(-0.5, 0.5, 0.5) + glVertex3f(-0.5,-0.5, 0.5) + glVertex3f( 0.5,-0.5, 0.5) + + glNormal3f( 0.0, 0.0,-1.0) + glVertex3f(-0.5,-0.5,-0.5) + glVertex3f(-0.5, 0.5,-0.5) + glVertex3f( 0.5, 0.5,-0.5) + glVertex3f( 0.5,-0.5,-0.5) + + glNormal3f( 0.0, 1.0, 0.0) + glVertex3f( 0.5, 0.5, 0.5) + glVertex3f( 0.5, 0.5,-0.5) + glVertex3f(-0.5, 0.5,-0.5) + glVertex3f(-0.5, 0.5, 0.5) + + glNormal3f( 0.0,-1.0, 0.0) + glVertex3f(-0.5,-0.5,-0.5) + glVertex3f( 0.5,-0.5,-0.5) + glVertex3f( 0.5,-0.5, 0.5) + glVertex3f(-0.5,-0.5, 0.5) + + glNormal3f( 1.0, 0.0, 0.0) + glVertex3f( 0.5, 0.5, 0.5) + glVertex3f( 0.5,-0.5, 0.5) + glVertex3f( 0.5,-0.5,-0.5) + glVertex3f( 0.5, 0.5,-0.5) + + glNormal3f(-1.0, 0.0, 0.0) + glVertex3f(-0.5,-0.5,-0.5) + glVertex3f(-0.5,-0.5, 0.5) + glVertex3f(-0.5, 0.5, 0.5) + glVertex3f(-0.5, 0.5,-0.5) + glEnd() + + self.SwapBuffers() + + + def InitGL(self): + # set viewing projection + glMatrixMode(GL_PROJECTION); + glFrustum(-0.5, 0.5, -0.5, 0.5, 1.0, 3.0); + + # position viewer + glMatrixMode(GL_MODELVIEW); + glTranslatef(0.0, 0.0, -2.0); + + # position object + glRotatef(30.0, 1.0, 0.0, 0.0); + glRotatef(30.0, 0.0, 1.0, 0.0); + + glEnable(GL_DEPTH_TEST); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + + + + + + + + + + + + + +overview = """\ +""" + + + + + +#---------------------------------------------------------------------- + +def _test(): + class MyApp(wxApp): + def OnInit(self): + frame = wxFrame(NULL, -1, "HELP ME!!") + win = TestGLCanvas(frame) + frame.Show(TRUE) + self.SetTopWindow(frame) + return TRUE + + app = MyApp(0) + app.MainLoop() + +if __name__ == '__main__': + _test() diff --git a/utils/wxPython/demo/wxGauge.py b/utils/wxPython/demo/wxGauge.py new file mode 100644 index 0000000000..3d26a6e727 --- /dev/null +++ b/utils/wxPython/demo/wxGauge.py @@ -0,0 +1,55 @@ + +from wxPython.wx import * + +#---------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + self.log = log + self.count = 0 + + wxStaticText(self, -1, "This example uses the wxGauge control.", + wxPoint(45, 15)) + + #self.g1 = wxGauge(self, -1, 50, wxPoint(40, 50), wxSize(40, 160), + # wxGA_VERTICAL) + #self.g1.SetBezelFace(3) + #self.g1.SetShadowWidth(3) + + self.g2 = wxGauge(self, -1, 50, wxPoint(110, 50), wxSize(250, 25), + wxGA_HORIZONTAL) + self.g2.SetBezelFace(5) + self.g2.SetShadowWidth(5) + + EVT_IDLE(self, self.IdleHandler) + + + def IdleHandler(self, event): + self.count = self.count + 1 + if self.count >= 50: + self.count = 0 + #self.g1.SetValue(self.count) + self.g2.SetValue(self.count) + + + +#---------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestPanel(nb, log) + return win + +#---------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxGrid.py b/utils/wxPython/demo/wxGrid.py new file mode 100644 index 0000000000..78431ca6c2 --- /dev/null +++ b/utils/wxPython/demo/wxGrid.py @@ -0,0 +1,77 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestGrid(wxGrid): + def __init__(self, parent, log): + wxGrid.__init__(self, parent, -1) + self.log = log + + self.CreateGrid(16, 16) + self.SetColumnWidth(3, 200) + self.SetRowHeight(4, 45) + self.SetCellValue("First cell", 0, 0) + self.SetCellValue("Another cell", 1, 1) + self.SetCellValue("Yet another cell", 2, 2) + self.SetCellTextFont(wxFont(12, wxROMAN, wxITALIC, wxNORMAL), 0, 0) + self.SetCellTextColour(wxRED, 1, 1) + self.SetCellBackgroundColour(wxCYAN, 2, 2) + self.UpdateDimensions() + self.AdjustScrollbars() + + EVT_GRID_SELECT_CELL(self, self.OnSelectCell) + EVT_GRID_CELL_CHANGE(self, self.OnCellChange) + EVT_GRID_CELL_LCLICK(self, self.OnCellClick) + EVT_GRID_LABEL_LCLICK(self, self.OnLabelClick) + + + + def OnSelectCell(self, event): + self.log.WriteText("OnSelectCell: (%d, %d)\n" % (event.m_row, event.m_col)) + + def OnCellChange(self, event): + self.log.WriteText("OnCellChange: (%d, %d)\n" % (event.m_row, event.m_col)) + + def OnCellClick(self, event): + self.log.WriteText("OnCellClick: (%d, %d)\n" % (event.m_row, event.m_col)) + + def OnLabelClick(self, event): + self.log.WriteText("OnLabelClick: (%d, %d)\n" % (event.m_row, event.m_col)) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestGrid(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + + + + + +overview = """\ +wxGrid is a class for displaying and editing tabular information. + +wxGrid() +----------------- + +wxGrid(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style=0, const wxString& name="grid") + +Constructor. Before using a wxGrid object, you must call CreateGrid to set up the required rows and columns. +""" diff --git a/utils/wxPython/demo/wxImage.py b/utils/wxPython/demo/wxImage.py new file mode 100644 index 0000000000..bed1c2ca8b --- /dev/null +++ b/utils/wxPython/demo/wxImage.py @@ -0,0 +1,40 @@ + +from wxPython.wx import * + +#---------------------------------------------------------------------- + +def runTest(frame, nb, log): + bmp = wxImage('bitmaps/image.bmp', wxBITMAP_TYPE_BMP).ConvertToBitmap() + gif = wxImage('bitmaps/image.gif', wxBITMAP_TYPE_GIF).ConvertToBitmap() + png = wxImage('bitmaps/image.png', wxBITMAP_TYPE_PNG).ConvertToBitmap() + jpg = wxImage('bitmaps/image.jpg', wxBITMAP_TYPE_JPEG).ConvertToBitmap() + + panel = wxPanel(nb, -1) + pos = 10 + wxStaticBitmap(panel, -1, bmp, wxPoint(10, pos), + wxSize(bmp.GetWidth(), bmp.GetHeight())) + + pos = pos + bmp.GetHeight() + 10 + wxStaticBitmap(panel, -1, gif, wxPoint(10, pos), + wxSize(gif.GetWidth(), gif.GetHeight())) + + pos = pos + gif.GetHeight() + 10 + wxStaticBitmap(panel, -1, png, wxPoint(10, pos), + wxSize(png.GetWidth(), png.GetHeight())) + + pos = pos + png.GetHeight() + 10 + wxStaticBitmap(panel, -1, jpg, wxPoint(10, pos), + wxSize(jpg.GetWidth(), jpg.GetHeight())) + + return panel + +#---------------------------------------------------------------------- + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxLayoutConstraints.py b/utils/wxPython/demo/wxLayoutConstraints.py new file mode 100644 index 0000000000..9182115d4c --- /dev/null +++ b/utils/wxPython/demo/wxLayoutConstraints.py @@ -0,0 +1,142 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestLayoutConstraints(wxWindow): + def __init__(self, parent): + wxWindow.__init__(self, parent, -1) + self.SetBackgroundColour(wxNamedColour("MEDIUM ORCHID")) + + self.SetAutoLayout(true) + EVT_BUTTON(self, 100, self.OnButton) + + self.panelA = wxWindow(self, -1, wxDefaultPosition, wxDefaultSize, + wxSIMPLE_BORDER) + self.panelA.SetBackgroundColour(wxBLUE) + txt = wxStaticText(self.panelA, -1, + "Resize the window and see\n" + "what happens... Notice that\n" + "there is no OnSize handler.", + wxPoint(5,5), wxSize(-1, 50)) + txt.SetBackgroundColour(wxBLUE) + txt.SetForegroundColour(wxWHITE) + + 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, wxDefaultPosition, wxDefaultSize, + 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, wxDefaultPosition, wxDefaultSize, + 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, wxDefaultPosition, wxDefaultSize, + 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): + wxBell() + + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestLayoutConstraints(nb) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + +overview = """\ +Objects of this class can be associated with a window to define its layout constraints, with respect to siblings or its parent. + +The class consists of the following eight constraints of class wxIndividualLayoutConstraint, some or all of which should be accessed directly to set the appropriate constraints. + +left: represents the left hand edge of the window + +right: represents the right hand edge of the window + +top: represents the top edge of the window + +bottom: represents the bottom edge of the window + +width: represents the width of the window + +height: represents the height of the window + +centreX: represents the horizontal centre point of the window + +centreY: represents the vertical centre point of the window + +Most constraints are initially set to have the relationship wxUnconstrained, which means that their values should be calculated by looking at known constraints. The exceptions are width and height, which are set to wxAsIs to ensure that if the user does not specify a constraint, the existing width and height will be used, to be compatible with panel items which often have take a default size. If the constraint is wxAsIs, the dimension will not be changed. + +wxLayoutConstraints() +------------------------------------------- + +Constructor. +""" diff --git a/utils/wxPython/demo/wxListBox.py b/utils/wxPython/demo/wxListBox.py new file mode 100644 index 0000000000..dd46fc5e30 --- /dev/null +++ b/utils/wxPython/demo/wxListBox.py @@ -0,0 +1,99 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestListBox(wxPanel): + def __init__(self, parent, log): + self.log = log + wxPanel.__init__(self, parent, -1) + + sampleList = ['zero', 'one', 'two', 'three', 'four', 'five', + 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', + 'twelve', 'thirteen', 'fourteen'] + + wxStaticText(self, -1, "This example uses the wxListBox control.", + wxPoint(45, 10)) + + wxStaticText(self, -1, "Select one:", wxPoint(15, 50), wxSize(65, 18)) + lb = wxListBox(self, 60, wxPoint(80, 50), wxSize(80, 120), + sampleList, wxLB_SINGLE) + EVT_LISTBOX(self, 60, self.EvtListBox) + EVT_LISTBOX_DCLICK(self, 60, self.EvtListBoxDClick) + lb.SetSelection(0) + + + wxStaticText(self, -1, "Select many:", wxPoint(200, 50), wxSize(65, 18)) + self.lb = wxListBox(self, 70, wxPoint(280, 50), wxSize(80, 120), + sampleList, wxLB_EXTENDED) + EVT_LISTBOX(self, 70, self.EvtMultiListBox) + EVT_LISTBOX_DCLICK(self, 70, self.EvtListBoxDClick) + self.lb.SetSelection(0) + + + def EvtListBox(self, event): + self.log.WriteText('EvtListBox: %s\n' % event.GetString()) + + def EvtListBoxDClick(self, event): + self.log.WriteText('EvtListBoxDClick:\n') + + def EvtMultiListBox(self, event): + self.log.WriteText('EvtMultiListBox: %s\n' % str(self.lb.GetSelections())) + + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestListBox(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + +overview = """\ +A listbox is used to select one or more of a list of strings. The strings are displayed in a scrolling box, with the selected string(s) marked in reverse video. A listbox can be single selection (if an item is selected, the previous selection is removed) or multiple selection (clicking an item toggles the item on or off independently of other selections). + +List box elements are numbered from zero. + +wxListBox() +--------------------- + +Default constructor. + +wxListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, int n, const wxString choices[] = NULL, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "listBox") + +Constructor, creating and showing a list box. + +Parameters +------------------- + +parent = Parent window. Must not be NULL. + +id = Window identifier. A value of -1 indicates a default value. + +pos = Window position. + +size = Window size. If the default size (-1, -1) is specified then the window is sized appropriately. + +n = Number of strings with which to initialise the control. + +choices = An array of strings with which to initialise the control. + +style = Window style. See wxListBox. + +validator = Window validator. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxListCtrl.py b/utils/wxPython/demo/wxListCtrl.py new file mode 100644 index 0000000000..a3d4daed82 --- /dev/null +++ b/utils/wxPython/demo/wxListCtrl.py @@ -0,0 +1,106 @@ +#!/bin/env python +#---------------------------------------------------------------------------- +# Name: ListCtrl.py +# Purpose: Testing lots of stuff, controls, window types, etc. +# +# Author: Robin Dunn & Gary Dumer +# +# Created: +# RCS-ID: $Id$ +# Copyright: (c) 1998 by Total Control Software +# Licence: wxWindows license +#---------------------------------------------------------------------------- + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestListCtrlPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + + self.log = log + tID = NewId() + + self.il = wxImageList(16, 16) + idx1 = self.il.Add(wxNoRefBitmap('bitmaps/smiles.bmp', wxBITMAP_TYPE_BMP)) + + self.list = wxListCtrl(self, tID, wxDefaultPosition, wxDefaultSize, + wxLC_REPORT|wxSUNKEN_BORDER) + self.list.SetImageList(self.il, wxIMAGE_LIST_SMALL) + + self.list.SetToolTip(wxToolTip("This is a ToolTip!")) + wxToolTip_Enable(true) + + self.list.InsertColumn(0, "Column 0") + self.list.InsertColumn(1, "Column 1") + self.list.InsertColumn(2, "One More Column (2)") + for x in range(50): + self.list.InsertImageStringItem(x, "This is item %d" % x, idx1) + self.list.SetStringItem(x, 1, "Col 1, item %d" % x) + self.list.SetStringItem(x, 2, "item %d in column 2" % x) + + self.list.SetColumnWidth(0, wxLIST_AUTOSIZE) + self.list.SetColumnWidth(1, wxLIST_AUTOSIZE) + self.list.SetColumnWidth(2, wxLIST_AUTOSIZE) + + + def OnSize(self, event): + w,h = self.GetClientSizeTuple() + self.list.SetDimensions(0, 0, w, h) + + + + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestListCtrlPanel(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + + +overview = """\ +A list control presents lists in a number of formats: list view, report view, icon view and small icon view. Elements are numbered from zero. + +wxListCtrl() +------------------------ + +Default constructor. + +wxListCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const wxString& name = "listCtrl") + +Constructor, creating and showing a list control. + +Parameters +------------------- + +parent = Parent window. Must not be NULL. + +id = Window identifier. A value of -1 indicates a default value. + +pos = Window position. + +size = Window size. If the default size (-1, -1) is specified then the window is sized appropriately. + +style = Window style. See wxListCtrl. + +validator = Window validator. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxMessageDialog.py b/utils/wxPython/demo/wxMessageDialog.py new file mode 100644 index 0000000000..344d7190d5 --- /dev/null +++ b/utils/wxPython/demo/wxMessageDialog.py @@ -0,0 +1,62 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + dlg = wxMessageDialog(frame, 'Hello from Python and wxPython!', + 'A Message Box', wxOK | wxICON_INFORMATION) + dlg.ShowModal() + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + +overview = """\ +wxMessageDialog() +---------------------------------- + +wxMessageDialog(wxWindow* parent, const wxString& message, const wxString& caption = "Message box", long style = wxOK | wxCANCEL | wxCENTRE, const wxPoint& pos = wxDefaultPosition) + +Constructor. Use wxMessageDialog::ShowModal to show the dialog. + +Parameters +------------------- + +parent = Parent window. + +message = Message to show on the dialog. + +caption = The dialog caption. + +style = A dialog style (bitlist) containing flags chosen from the following: + +wxOK Show an OK button. + +wxCANCEL Show a Cancel button. + +wxYES_NO Show Yes and No buttons. + +wxCENTRE Centre the message. Not Windows. + +wxICON_EXCLAMATION Shows an exclamation mark icon. Windows only. + +wxICON_HAND Shows a hand icon. Windows only. + +wxICON_QUESTION Shows a question mark icon. Windows only. + +wxICON_INFORMATION Shows an information (i) icon. Windows only. + +pos = Dialog position. +""" diff --git a/utils/wxPython/demo/wxMiniFrame.py b/utils/wxPython/demo/wxMiniFrame.py new file mode 100644 index 0000000000..ba9d7e527b --- /dev/null +++ b/utils/wxPython/demo/wxMiniFrame.py @@ -0,0 +1,42 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- +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) + + button = wxButton(panel, 1003, "Close Me") + button.SetPosition(wxPoint(15, 15)) + EVT_BUTTON(self, 1003, self.OnCloseMe) + + def OnCloseMe(self, event): + self.Close(true) + + def OnCloseWindow(self, event): + self.Destroy() + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = MyMiniFrame(frame, -1, "This is a wxMiniFrame", + wxDefaultPosition, wxSize(200, 200), + wxDEFAULT_FRAME_STYLE | wxTINY_CAPTION_HORIZ) + frame.otherWin = win + win.Show(true) + + +#--------------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxMultipleChoiceDialog.py b/utils/wxPython/demo/wxMultipleChoiceDialog.py new file mode 100644 index 0000000000..6e3fb5de55 --- /dev/null +++ b/utils/wxPython/demo/wxMultipleChoiceDialog.py @@ -0,0 +1,27 @@ + +from wxPython.wx import * +from wxPython.lib.dialogs import wxMultipleChoiceDialog + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', + 'etc', 'etc..', 'etc...' ] + dlg = wxMultipleChoiceDialog(frame, + "Pick some from\n this list\nblah blah...", + "m.s.d.", lst) + if (dlg.ShowModal() == wxID_OK): + print "Selection:", dlg.GetValue(), " -> ", dlg.GetValueString() + +#--------------------------------------------------------------------------- + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxNotebook.py b/utils/wxPython/demo/wxNotebook.py new file mode 100644 index 0000000000..51c68d5825 --- /dev/null +++ b/utils/wxPython/demo/wxNotebook.py @@ -0,0 +1,84 @@ + +from wxPython.wx import * +import ColorPanel + +#---------------------------------------------------------------------------- + +def runTest(frame, nb, log): + + testWin = wxNotebook(nb, -1) + + win = ColorPanel.ColoredPanel(testWin, wxBLUE) + testWin.AddPage(win, "Blue") + st = wxStaticText(win, -1, + "You can put nearly any type of window here!", + wxPoint(10, 10)) + st.SetForegroundColour(wxWHITE) + st.SetBackgroundColour(wxBLUE) + + win = ColorPanel.ColoredPanel(testWin, wxRED) + testWin.AddPage(win, "Red") + + win = ColorPanel.ColoredPanel(testWin, wxGREEN) + testWin.AddPage(win, "Green") + + win = ColorPanel.ColoredPanel(testWin, wxCYAN) + testWin.AddPage(win, "Cyan") + + win = ColorPanel.ColoredPanel(testWin, wxWHITE) + testWin.AddPage(win, "White") + + win = ColorPanel.ColoredPanel(testWin, wxBLACK) + testWin.AddPage(win, "Black") + + win = ColorPanel.ColoredPanel(testWin, wxNamedColour('MIDNIGHT BLUE')) + testWin.AddPage(win, "MIDNIGHT BLUE") + + win = ColorPanel.ColoredPanel(testWin, wxNamedColour('INDIAN RED')) + testWin.AddPage(win, "INDIAN RED") + + return testWin + +#---------------------------------------------------------------------------- + + + + + + + + + + + + + + + +overview = """\ +This class represents a notebook control, which manages multiple windows with associated tabs. + +To use the class, create a wxNotebook object and call AddPage or InsertPage, passing a window to be used as the page. Do not explicitly delete the window for a page that is currently managed by wxNotebook. + +wxNotebook() +------------------------- + +Default constructor. + +wxNotebook(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size, long style = 0, const wxString& name = "notebook") + +Constructs a notebook control. + +Parameters +------------------- + +parent = The parent window. Must be non-NULL. + +id = The window identifier. + +pos = The window position. + +size = The window size. + +style = The window style. Its value is a bit list of zero or more of wxTC_MULTILINE, wxTC_RIGHTJUSTIFY, wxTC_FIXEDWIDTH and wxTC_OWNERDRAW. +""" diff --git a/utils/wxPython/demo/wxPageSetupDialog.py b/utils/wxPython/demo/wxPageSetupDialog.py new file mode 100644 index 0000000000..61ae29290d --- /dev/null +++ b/utils/wxPython/demo/wxPageSetupDialog.py @@ -0,0 +1,33 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + data = wxPageSetupDialogData() + data.SetMarginTopLeft(wxPoint(50,50)) + data.SetMarginBottomRight(wxPoint(50,50)) + dlg = wxPageSetupDialog(frame, data) + if dlg.ShowModal() == wxID_OK: + data = dlg.GetPageSetupData() + tl = data.GetMarginTopLeft() + br = data.GetMarginBottomRight() + log.WriteText('Margins are: %s %s\n' % (str(tl), str(br))) + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxPlotCanvas.py b/utils/wxPython/demo/wxPlotCanvas.py new file mode 100644 index 0000000000..1a9f7b2271 --- /dev/null +++ b/utils/wxPython/demo/wxPlotCanvas.py @@ -0,0 +1,39 @@ + +from wxPython.lib.wxPlotCanvas import * +from wxPython.lib import wxPlotCanvas + +#--------------------------------------------------------------------------- + +def _InitObjects(): + # 100 points sin function, plotted as green circles + data1 = 2.*Numeric.pi*Numeric.arange(200)/200. + data1.shape = (100, 2) + data1[:,1] = Numeric.sin(data1[:,0]) + markers1 = PolyMarker(data1, color='green', marker='circle',size=1) + + # 50 points cos function, plotted as red line + data1 = 2.*Numeric.pi*Numeric.arange(100)/100. + data1.shape = (50,2) + data1[:,1] = Numeric.cos(data1[:,0]) + lines = PolyLine(data1, color='red') + + # A few more points... + pi = Numeric.pi + markers2 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.), + (3.*pi/4., -1)], color='blue', + fillcolor='green', marker='cross') + + return PlotGraphics([markers1, lines, markers2]) + + +#--------------------------------------------------------------------------- + + +def runTest(frame, nb, log): + win = PlotCanvas(nb) + win.draw(_InitObjects(),'automatic','automatic'); + return win + +overview = wxPlotCanvas.__doc__ + +#--------------------------------------------------------------------------- diff --git a/utils/wxPython/demo/wxPrintDialog.py b/utils/wxPython/demo/wxPrintDialog.py new file mode 100644 index 0000000000..50da750bd2 --- /dev/null +++ b/utils/wxPython/demo/wxPrintDialog.py @@ -0,0 +1,31 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + data = wxPrintDialogData() + data.EnablePrintToFile(true) + data.EnablePageNumbers(true) + data.EnableSelection(true) + dlg = wxPrintDialog(frame, data) + if dlg.ShowModal() == wxID_OK: + log.WriteText('\n') + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxRadioBox.py b/utils/wxPython/demo/wxRadioBox.py new file mode 100644 index 0000000000..dbd28fd597 --- /dev/null +++ b/utils/wxPython/demo/wxRadioBox.py @@ -0,0 +1,76 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestRadioButtons(wxPanel): + def __init__(self, parent, log): + self.log = log + wxPanel.__init__(self, parent, -1) + + sampleList = ['zero', 'one', 'two', 'three', 'four', 'five', + 'six', 'seven', 'eight'] + + rb = wxRadioBox(self, 30, "wxRadioBox", wxPoint(35, 30), wxDefaultSize, + sampleList, 3, wxRA_SPECIFY_COLS | wxNO_BORDER) + EVT_RADIOBOX(self, 30, self.EvtRadioBox) + + + def EvtRadioBox(self, event): + self.log.WriteText('EvtRadioBox: %d\n' % event.GetInt()) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestRadioButtons(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + +overview = """\ +A radio box item is used to select one of number of mutually exclusive choices. It is displayed as a vertical column or horizontal row of labelled buttons. + +wxRadioBox() +---------------------- + +Default constructor. + +wxRadioBox(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& point = wxDefaultPosition, const wxSize& size = wxDefaultSize, int n = 0, const wxString choices[] = NULL, int majorDimension = 0, long style = wxRA_SPECIFY_COLS, const wxValidator& validator = wxDefaultValidator, const wxString& name = "radioBox") + +Constructor, creating and showing a radiobox. + +Parameters +------------------- + +parent = Parent window. Must not be NULL. + +id = Window identifier. A value of -1 indicates a default value. + +label = Label for the static box surrounding the radio buttons. + +pos = Window position. If the position (-1, -1) is specified then a default position is chosen. + +size = Window size. If the default size (-1, -1) is specified then a default size is chosen. + +n = Number of choices with which to initialize the radiobox. + +choices = An array of choices with which to initialize the radiobox. + +majorDimension = Specifies the maximum number of rows (if style contains wxRA_SPECIFY_ROWS) or columns (if style contains wxRA_SPECIFY_COLS) for a two-dimensional radiobox. + +style = Window style. See wxRadioBox. + +validator = Window validator. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxSashWindow.py b/utils/wxPython/demo/wxSashWindow.py new file mode 100644 index 0000000000..446ffce9e4 --- /dev/null +++ b/utils/wxPython/demo/wxSashWindow.py @@ -0,0 +1,152 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestSashWindow(wxPanel): + ID_WINDOW_TOP = 5100 + ID_WINDOW_LEFT1 = 5101 + ID_WINDOW_LEFT2 = 5102 + ID_WINDOW_BOTTOM = 5103 + + + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + + self.log = log + + EVT_SASH_DRAGGED_RANGE(self, self.ID_WINDOW_TOP, + self.ID_WINDOW_BOTTOM, self.OnSashDrag) + + + # Create some layout windows + # A window like a toolbar + win = wxSashLayoutWindow(self, self.ID_WINDOW_TOP, wxDefaultPosition, + wxSize(200, 30), wxNO_BORDER|wxSW_3D) + win.SetDefaultSize(wxSize(1000, 30)) + win.SetOrientation(wxLAYOUT_HORIZONTAL) + win.SetAlignment(wxLAYOUT_TOP) + win.SetBackgroundColour(wxColour(255, 0, 0)) + win.SetSashVisible(wxSASH_BOTTOM, true) + + self.topWindow = win + + + # A window like a statusbar + win = wxSashLayoutWindow(self, self.ID_WINDOW_BOTTOM, + wxDefaultPosition, wxSize(200, 30), + wxNO_BORDER|wxSW_3D) + win.SetDefaultSize(wxSize(1000, 30)) + win.SetOrientation(wxLAYOUT_HORIZONTAL) + win.SetAlignment(wxLAYOUT_BOTTOM) + win.SetBackgroundColour(wxColour(0, 0, 255)) + win.SetSashVisible(wxSASH_TOP, true) + + self.bottomWindow = win + + + # A window to the left of the client window + win = wxSashLayoutWindow(self, self.ID_WINDOW_LEFT1, + wxDefaultPosition, wxSize(200, 30), + wxNO_BORDER|wxSW_3D) + win.SetDefaultSize(wxSize(120, 1000)) + win.SetOrientation(wxLAYOUT_VERTICAL) + win.SetAlignment(wxLAYOUT_LEFT) + win.SetBackgroundColour(wxColour(0, 255, 0)) + win.SetSashVisible(wxSASH_RIGHT, TRUE) + win.SetExtraBorderSize(10) + + textWindow = wxTextCtrl(win, -1, "", wxDefaultPosition, wxDefaultSize, + wxTE_MULTILINE|wxSUNKEN_BORDER) + textWindow.SetValue("A help window") + + self.leftWindow1 = win + + + # Another window to the left of the client window + win = wxSashLayoutWindow(self, self.ID_WINDOW_LEFT2, + wxDefaultPosition, wxSize(200, 30), + wxNO_BORDER|wxSW_3D) + win.SetDefaultSize(wxSize(120, 1000)) + win.SetOrientation(wxLAYOUT_VERTICAL) + win.SetAlignment(wxLAYOUT_LEFT) + win.SetBackgroundColour(wxColour(0, 255, 255)) + win.SetSashVisible(wxSASH_RIGHT, TRUE) + + self.leftWindow2 = win + + + def OnSashDrag(self, event): + if event.GetDragStatus() == wxSASH_STATUS_OUT_OF_RANGE: + return + + eID = event.GetId() + if eID == self.ID_WINDOW_TOP: + self.topWindow.SetDefaultSize(wxSize(1000, event.GetDragRect().height)) + + elif eID == self.ID_WINDOW_LEFT1: + self.leftWindow1.SetDefaultSize(wxSize(event.GetDragRect().width, 1000)) + + + elif eID == self.ID_WINDOW_LEFT2: + self.leftWindow2.SetDefaultSize(wxSize(event.GetDragRect().width, 1000)) + + elif eID == self.ID_WINDOW_BOTTOM: + self.bottomWindow.SetDefaultSize(wxSize(1000, event.GetDragRect().height)) + + wxLayoutAlgorithm().LayoutWindow(self) + + + def OnSize(self, event): + wxLayoutAlgorithm().LayoutWindow(self) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestSashWindow(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + + +overview = """\ +wxSashLayoutWindow responds to OnCalculateLayout events generated by wxLayoutAlgorithm. It allows the application to use simple accessors to specify how the window should be laid out, rather than having to respond to events. The fact that the class derives from wxSashWindow allows sashes to be used if required, to allow the windows to be user-resizable. + +wxSashLayoutWindow() +------------------------------------------- + +Default constructor. + +wxSashLayoutWindow(wxSashLayoutWindow* parent, wxSashLayoutWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCLIP_CHILDREN | wxSW_3D, const wxString& name = "layoutWindow") + +Constructs a sash layout window, which can be a child of a frame, dialog or any other non-control window. + +Parameters +------------------- + +parent = Pointer to a parent window. + +id = Window identifier. If -1, will automatically create an identifier. + +pos = Window position. wxDefaultPosition is (-1, -1) which indicates that wxSashLayoutWindows should generate a default position for the window. If using the wxSashLayoutWindow class directly, supply an actual position. + +size = Window size. wxDefaultSize is (-1, -1) which indicates that wxSashLayoutWindows should generate a default size for the window. + +style = Window style. For window styles, please see wxSashLayoutWindow. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxScrolledMessageDialog.py b/utils/wxPython/demo/wxScrolledMessageDialog.py new file mode 100644 index 0000000000..e50d1e7c9e --- /dev/null +++ b/utils/wxPython/demo/wxScrolledMessageDialog.py @@ -0,0 +1,24 @@ + +from wxPython.wx import * +from wxPython.lib.dialogs import wxScrolledMessageDialog + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + f = open("Main.py", "r") + msg = f.read() + dlg = wxScrolledMessageDialog(frame, msg, "message test") + dlg.ShowModal() + +#--------------------------------------------------------------------------- + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxScrolledWindow.py b/utils/wxPython/demo/wxScrolledWindow.py new file mode 100644 index 0000000000..7012e38f9a --- /dev/null +++ b/utils/wxPython/demo/wxScrolledWindow.py @@ -0,0 +1,122 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class MyCanvas(wxScrolledWindow): + def __init__(self, parent): + wxScrolledWindow.__init__(self, parent, -1, wxPoint(0, 0), wxPyDefaultSize, wxSUNKEN_BORDER) + + self.lines = [] + + self.SetBackgroundColour(wxNamedColor("WHITE")) + 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) + self.bmp = bmp + + self.SetScrollbars(20, 20, 50, 50) + + + def OnPaint(self, event): + dc = wxPaintDC(self) + self.PrepareDC(dc) + 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 SetXY(self, event): + self.x, self.y = self.ConvertEventCoords(event) + + def ConvertEventCoords(self, event): + xView, yView = self.ViewStart() + xDelta, yDelta = self.GetScrollPixelsPerUnit() + return (event.GetX() + (xView * xDelta), + event.GetY() + (yView * yDelta)) + + def OnLeftButtonEvent(self, event): + if event.LeftDown(): + self.SetXY(event) + self.curLine = [] + + elif event.Dragging(): + dc = wxClientDC(self) + self.PrepareDC(dc) + dc.BeginDrawing() + dc.SetPen(wxPen(wxNamedColour('MEDIUM FOREST GREEN'), 4)) + coords = (self.x, self.y) + self.ConvertEventCoords(event) + self.curLine.append(coords) + apply(dc.DrawLine, coords) + self.SetXY(event) + dc.EndDrawing() + + elif event.LeftUp(): + self.lines.append(self.curLine) + self.curLine = [] + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = MyCanvas(nb) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxSingleChoiceDialog.py b/utils/wxPython/demo/wxSingleChoiceDialog.py new file mode 100644 index 0000000000..9b34808f13 --- /dev/null +++ b/utils/wxPython/demo/wxSingleChoiceDialog.py @@ -0,0 +1,59 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + dlg = wxSingleChoiceDialog(frame, 'Test Single Choice', 'The Caption', + ['zero', 'one', 'two', 'three', 'four', 'five', + 'six', 'seven', 'eight']) + if dlg.ShowModal() == wxID_OK: + log.WriteText('You selected: %s\n' % dlg.GetStringSelection()) + dlg.Destroy() + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + +overview = """\ +This class represents a dialog that shows a list of strings, and allows the user to select one. Double-clicking on a list item is equivalent to single-clicking and then pressing OK. + +wxSingleChoiceDialog() +--------------------------------------------- + +wxSingleChoiceDialog(wxWindow* parent, const wxString& message, const wxString& caption, int n, const wxString* choices, char** clientData = NULL, long style = wxOK | wxCANCEL | wxCENTRE, const wxPoint& pos = wxDefaultPosition) + +Constructor, taking an array of wxString choices and optional client data. + +Parameters +------------------- + +parent = Parent window. + +message = Message to show on the dialog. + +caption = The dialog caption. +n = The number of choices. + +choices = An array of strings, or a string list, containing the choices. + +style = A dialog style (bitlist) containing flags chosen from the following: + +wxOK Show an OK button. + +wxCANCEL Show a Cancel button. + +wxCENTRE Centre the message. Not Windows. + +pos = Dialog position. +""" diff --git a/utils/wxPython/demo/wxSlider.py b/utils/wxPython/demo/wxSlider.py new file mode 100644 index 0000000000..731486ee2b --- /dev/null +++ b/utils/wxPython/demo/wxSlider.py @@ -0,0 +1,41 @@ + +from wxPython.wx import * + +import string + +#---------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + self.log = log + self.count = 0 + + wxStaticText(self, -1, "This is a wxSlider.", wxPoint(45, 15)) + + slider = wxSlider(self, 100, 25, 1, 100, wxPoint(30, 60), + wxSize(250, -1), + wxSL_HORIZONTAL | wxSL_AUTOTICKS | wxSL_LABELS ) + slider.SetTickFreq(5, 1) + + + +#---------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestPanel(nb, log) + return win + +#---------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxSpinButton.py b/utils/wxPython/demo/wxSpinButton.py new file mode 100644 index 0000000000..4974e1cef0 --- /dev/null +++ b/utils/wxPython/demo/wxSpinButton.py @@ -0,0 +1,49 @@ + +from wxPython.wx import * + +import string + +#---------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + self.log = log + self.count = 0 + + wxStaticText(self, -1, "This example uses the wxSpinButton control.", + wxPoint(45, 15)) + + + self.text = wxTextCtrl(self, -1, "1", wxPoint(30, 50), wxSize(60, -1)) + h = self.text.GetSize().height + self.spin = wxSpinButton(self, 20, wxPoint(92, 50), wxSize(h*2, h)) + self.spin.SetRange(1, 100) + self.spin.SetValue(1) + + EVT_SPIN(self, 20, self.OnSpin) + + + def OnSpin(self, event): + self.text.SetValue(str(event.GetPosition())) + + +#---------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestPanel(nb, log) + return win + +#---------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxSplitterWindow.py b/utils/wxPython/demo/wxSplitterWindow.py new file mode 100644 index 0000000000..20b4929c60 --- /dev/null +++ b/utils/wxPython/demo/wxSplitterWindow.py @@ -0,0 +1,67 @@ + +from wxPython.wx import * + + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + splitter = wxSplitterWindow(nb, -1) + + p1 = wxWindow(splitter, -1) + p1.SetBackgroundColour(wxRED) + wxStaticText(p1, -1, "Panel One", wxPoint(5,5)).SetBackgroundColour(wxRED) + + p2 = wxWindow(splitter, -1) + p2.SetBackgroundColour(wxBLUE) + wxStaticText(p2, -1, "Panel Two", wxPoint(5,5)).SetBackgroundColour(wxBLUE) + + splitter.SplitVertically(p1, p2) + splitter.SetSashPosition(100) + splitter.SetMinimumPaneSize(20) + + return splitter + + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + +overview = """\ +This class manages up to two subwindows. The current view can be split into two programmatically (perhaps from a menu command), and unsplit either programmatically or via the wxSplitterWindow user interface. + +wxSplitterWindow() +----------------------------------- + +Default constructor. + +wxSplitterWindow(wxWindow* parent, wxWindowID id, int x, const wxPoint& point = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style=wxSP_3D, const wxString& name = "splitterWindow") + +Constructor for creating the window. + +Parameters +------------------- + +parent = The parent of the splitter window. + +id = The window identifier. + +pos = The window position. + +size = The window size. + +style = The window style. See wxSplitterWindow. + +name = The window name. +""" diff --git a/utils/wxPython/demo/wxStaticBitmap.py b/utils/wxPython/demo/wxStaticBitmap.py new file mode 100644 index 0000000000..cb9c8df10b --- /dev/null +++ b/utils/wxPython/demo/wxStaticBitmap.py @@ -0,0 +1,41 @@ + +from wxPython.wx import * + +import string + +#---------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + self.log = log + self.count = 0 + + wxStaticText(self, -1, "This is a wxStaticBitmap.", wxPoint(45, 15)) + + bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP) + wxStaticBitmap(self, -1, bmp, wxPoint(80, 50), + wxSize(bmp.GetWidth(), bmp.GetHeight())) + + + + +#---------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestPanel(nb, log) + return win + +#---------------------------------------------------------------------- + + + + + + + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxStaticText.py b/utils/wxPython/demo/wxStaticText.py new file mode 100644 index 0000000000..baba79cf08 --- /dev/null +++ b/utils/wxPython/demo/wxStaticText.py @@ -0,0 +1,73 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent): + wxPanel.__init__(self, parent, -1) + + wxStaticText(self, -1, "This is an example of static text", + wxPoint(20, 10)) + + wxStaticText(self, -1, "using the wxStaticText Control.", + wxPoint(20, 30)) + + wxStaticText(self, -1, "Is this yellow?", + wxPoint(20, 70)).SetBackgroundColour(wxNamedColour('Yellow')) + + str = "This is a different font." + text = wxStaticText(self, -1, str, wxPoint(20, 100)) + font = wxFont(20, wxSWISS, wxNORMAL, wxNORMAL, false, "Arial") + w, h, d, e = self.GetFullTextExtent(str, font) + text.SetFont(font) + text.SetSize(wxSize(w, h)) + + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + panel = TestPanel(nb) + return panel + + +#--------------------------------------------------------------------------- + + + + + + + + +overview = '''\ +A static text control displays one or more lines of read-only text. + +wxStaticText() +------------------------- + +Default constructor. + +wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label = "", const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "staticText") + +Constructor, creating and showing a text control. + +Parameters +------------------- + +parent = Parent window. Should not be NULL. + +id = Control identifier. A value of -1 denotes a default value. + +label = Text label. + +pos = Window position. + +size = Window size. + +style = Window style. See wxStaticText. + +name = Window name. +''' + +#--------------------------------------------------------------------------- diff --git a/utils/wxPython/demo/wxStatusBar.py b/utils/wxPython/demo/wxStatusBar.py new file mode 100644 index 0000000000..97c32980eb --- /dev/null +++ b/utils/wxPython/demo/wxStatusBar.py @@ -0,0 +1,114 @@ + +from wxPython.wx import * + +import time + +#--------------------------------------------------------------------------- + +class CustomStatusBar(wxStatusBar): + def __init__(self, parent, log): + wxStatusBar.__init__(self, parent, -1) + self.SetFieldsCount(3) + self.log = log + + self.SetStatusText("A Custom StatusBar...", 0) + + self.cb = wxCheckBox(self, 1001, "toggle clock") + EVT_CHECKBOX(self, 1001, self.OnToggleClock) + self.cb.SetValue(true) + + # figure out how tall to make it. + dc = wxClientDC(self) + dc.SetFont(self.GetFont()) + (w,h) = dc.GetTextExtent('X') + h = int(h * 1.8) + self.SetSize(wxSize(100, h)) + + # start our timer + self.timer = wxPyTimer(self.Notify) + self.timer.Start(1000) + self.Notify() + + + # Time-out handler + def Notify(self): + t = time.localtime(time.time()) + st = time.strftime("%d-%b-%Y %I:%M:%S", t) + self.SetStatusText(st, 2) + self.log.WriteText("tick...\n") + + # the checkbox was clicked + def OnToggleClock(self, event): + if self.cb.GetValue(): + self.timer.Start(1000) + self.Notify() + else: + self.timer.Stop() + + + # reposition the checkbox + def OnSize(self, event): + rect = self.GetFieldRect(1) + self.cb.SetPosition(wxPoint(rect.x+2, rect.y+2)) + self.cb.SetSize(wxSize(rect.width-4, rect.height-4)) + + + +class TestCustomStatusBar(wxFrame): + def __init__(self, parent, log): + wxFrame.__init__(self, parent, -1, 'Test Custom StatusBar', + wxPoint(0,0), wxSize(500, 300)) + wxWindow(self, -1).SetBackgroundColour(wxNamedColour("WHITE")) + + self.sb = CustomStatusBar(self, log) + self.SetStatusBar(self.sb) + + def OnCloseWindow(self, event): + self.sb.timer.Stop() + del self.sb.timer + self.Destroy() + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestCustomStatusBar(frame, log) + frame.otherWin = win + win.Show(true) + +#--------------------------------------------------------------------------- + + + + + + + + + +overview = """\ +A status bar is a narrow window that can be placed along the bottom of a frame to give small amounts of status information. It can contain one or more fields, one or more of which can be variable length according to the size of the window. + +wxStatusBar() +---------------------------- + +Default constructor. + +wxStatusBar(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "statusBar") + +Constructor, creating the window. + +Parameters +------------------- + +parent = The window parent, usually a frame. + +id = The window identifier. It may take a value of -1 to indicate a default value. + +pos = The window position. A value of (-1, -1) indicates a default position, chosen by either the windowing system or wxWindows, depending on platform. + +size = The window size. A value of (-1, -1) indicates a default size, chosen by either the windowing system or wxWindows, depending on platform. + +style = The window style. See wxStatusBar. + +name = The name of the window. This parameter is used to associate a name with the item, allowing the application user to set Motif resource values for individual windows. +""" diff --git a/utils/wxPython/demo/wxTextCtrl.py b/utils/wxPython/demo/wxTextCtrl.py new file mode 100644 index 0000000000..49eaa00e75 --- /dev/null +++ b/utils/wxPython/demo/wxTextCtrl.py @@ -0,0 +1,40 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + self.log = log + + wxStaticText(self, -1, "wxTextCtrl", wxPoint(5, 25), wxSize(75, 20)) + wxTextCtrl(self, 10, "", wxPoint(80, 25), wxSize(150, 20)) + EVT_TEXT(self, 10, self.EvtText) + + wxStaticText(self, -1, "Passsword", wxPoint(5, 50), wxSize(75, 20)) + wxTextCtrl(self, 20, "", wxPoint(80, 50), wxSize(150, 20), wxTE_PASSWORD) + EVT_TEXT(self, 20, self.EvtText) + + wxStaticText(self, -1, "Multi-line", wxPoint(5, 75), wxSize(75, 20)) + wxTextCtrl(self, 30, "", wxPoint(80, 75), wxSize(200, 150), wxTE_MULTILINE) + EVT_TEXT(self, 30, self.EvtText) + + def EvtText(self, event): + self.log.WriteText('EvtText: %s\n' % event.GetString()) + + + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestPanel(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + +overview = """\ +""" diff --git a/utils/wxPython/demo/wxTextEntryDialog.py b/utils/wxPython/demo/wxTextEntryDialog.py new file mode 100644 index 0000000000..08e93e237e --- /dev/null +++ b/utils/wxPython/demo/wxTextEntryDialog.py @@ -0,0 +1,50 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + dlg = wxTextEntryDialog(frame, 'What is your favorite programming language?', + 'Duh??', 'Python') + dlg.SetValue("Python is the best!") #### this doesn't work? + if dlg.ShowModal() == wxID_OK: + log.WriteText('You entered: %s\n' % dlg.GetValue()) + dlg.Destroy() + + +#--------------------------------------------------------------------------- + + + + + + + + + + + + +overview = """\ +This class represents a dialog that requests a one-line text string from the user. It is implemented as a generic wxWindows dialog. + +wxTextEntryDialog() +---------------------------------- + +wxTextEntryDialog(wxWindow* parent, const wxString& message, const wxString& caption = "Please enter text", const wxString& defaultValue = "", long style = wxOK | wxCANCEL | wxCENTRE, const wxPoint& pos = wxDefaultPosition) + +Constructor. Use wxTextEntryDialog::ShowModal to show the dialog. + +Parameters +------------------- + +parent = Parent window. + +message = Message to show on the dialog. + +defaultValue = The default value, which may be the empty string. + +style = A dialog style, specifying the buttons (wxOK, wxCANCEL) and an optional wxCENTRE style. + +pos = Dialog position. +""" diff --git a/utils/wxPython/demo/wxTimer.py b/utils/wxPython/demo/wxTimer.py new file mode 100644 index 0000000000..a32f3d3500 --- /dev/null +++ b/utils/wxPython/demo/wxTimer.py @@ -0,0 +1,67 @@ + +from wxPython.wx import * + +import time + +#--------------------------------------------------------------------------- + +class TestTimer(wxTimer): + def __init__(self, log = None): + wxTimer.__init__(self) + self.log = log + + def Notify(self): + wxBell() + if self.log: + self.log.WriteText('beep!\n') + +#--------------------------------------------------------------------------- + +_timer = TestTimer() + + +class TestTimerWin(wxPanel): + def __init__(self, parent, log): + _timer.log = log + wxPanel.__init__(self, parent, -1) + + wxStaticText(self, -1, "This is a timer example", + wxPoint(15, 30)) + + wxButton(self, 11101, ' Start ', wxPoint(15, 75), wxDefaultSize) + wxButton(self, 11102, ' Stop ', wxPoint(77, 75), wxDefaultSize) + EVT_BUTTON(self, 11101, self.OnStart) + EVT_BUTTON(self, 11102, self.OnStop) + + def OnStart(self, event): + _timer.Start(1000) + + def OnStop(self, event): + _timer.Stop() + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestTimerWin(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + +overview = """\ +The wxTimer class allows you to execute code at specified intervals. To use it, derive a new class and override the Notify member to perform the required action. Start with Start, stop with Stop, it's as simple as that. + +wxTimer() +------------------ + +Constructor. +""" diff --git a/utils/wxPython/demo/wxToolBar.py b/utils/wxPython/demo/wxToolBar.py new file mode 100644 index 0000000000..d49195ba75 --- /dev/null +++ b/utils/wxPython/demo/wxToolBar.py @@ -0,0 +1,125 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestToolBar(wxFrame): + def __init__(self, parent, log): + wxFrame.__init__(self, parent, -1, 'Test ToolBar', + wxPoint(0,0), wxSize(500, 300)) + self.log = log + + wxWindow(self, -1).SetBackgroundColour(wxNamedColour("WHITE")) + + tb = self.CreateToolBar(wxTB_HORIZONTAL|wxNO_BORDER) + #tb = wxToolBar(self, -1, wxDefaultPosition, wxDefaultSize, + # wxTB_HORIZONTAL | wxNO_BORDER | wxTB_FLAT) + #self.SetToolBar(tb) + + self.CreateStatusBar() + + tb.AddTool(10, wxNoRefBitmap('bitmaps/new.bmp', wxBITMAP_TYPE_BMP), + wxNullBitmap, false, -1, -1, "New", "Long help for 'New'") + EVT_TOOL(self, 10, self.OnToolClick) + EVT_TOOL_RCLICKED(self, 10, self.OnToolRClick) + + tb.AddTool(20, wxNoRefBitmap('bitmaps/open.bmp', wxBITMAP_TYPE_BMP), + wxNullBitmap, false, -1, -1, "Open") + EVT_TOOL(self, 20, self.OnToolClick) + EVT_TOOL_RCLICKED(self, 20, self.OnToolRClick) + + tb.AddSeparator() + tb.AddTool(30, wxNoRefBitmap('bitmaps/copy.bmp', wxBITMAP_TYPE_BMP), + wxNullBitmap, false, -1, -1, "Copy") + EVT_TOOL(self, 30, self.OnToolClick) + EVT_TOOL_RCLICKED(self, 30, self.OnToolRClick) + + tb.AddTool(40, wxNoRefBitmap('bitmaps/paste.bmp', wxBITMAP_TYPE_BMP), + wxNullBitmap, false, -1, -1, "Paste") + EVT_TOOL(self, 40, self.OnToolClick) + EVT_TOOL_RCLICKED(self, 40, self.OnToolRClick) + + tb.AddSeparator() + + tb.AddTool(50, wxNoRefBitmap('bitmaps/tog1.bmp', wxBITMAP_TYPE_BMP), + wxNullBitmap, true, -1, -1, "Toggle this") + EVT_TOOL(self, 50, self.OnToolClick) + EVT_TOOL_RCLICKED(self, 50, self.OnToolRClick) + + tb.AddTool(60, wxNoRefBitmap('bitmaps/tog1.bmp', wxBITMAP_TYPE_BMP), + wxNoRefBitmap('bitmaps/tog2.bmp', wxBITMAP_TYPE_BMP), + true, -1, -1, "Toggle with 2 bitmaps") + EVT_TOOL(self, 60, self.OnToolClick) + EVT_TOOL_RCLICKED(self, 60, self.OnToolRClick) + + tb.Realize() + + + def OnCloseWindow(self, event): + self.Destroy() + + def OnToolClick(self, event): + self.log.WriteText("tool %s clicked\n" % event.GetId()) + + def OnToolRClick(self, event): + self.log.WriteText("tool %s right-clicked\n" % event.GetId()) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestToolBar(frame, log) + frame.otherWin = win + win.Show(true) + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + + +overview = """\ +The name wxToolBar is defined to be a synonym for one of the following classes: + +wxToolBar95 The native Windows 95 toolbar. Used on Windows 95, NT 4 and above. + +wxToolBarMSW A Windows implementation. Used on 16-bit Windows. + +wxToolBarGTK The GTK toolbar. + +wxToolBarSimple A simple implementation, with scrolling. Used on platforms with no native toolbar control, or where scrolling is required. + +wxToolBar() +----------------------- + +Default constructor. + +wxToolBar(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTB_HORIZONTAL | wxNO_BORDER, const wxString& name = wxPanelNameStr) + +Constructs a toolbar. + +Parameters +------------------- + +parent = Pointer to a parent window. + +id = Window identifier. If -1, will automatically create an identifier. + +pos = Window position. wxDefaultPosition is (-1, -1) which indicates that wxWindows should generate a default position for the window. If using the wxWindow class directly, supply an actual position. + +size = Window size. wxDefaultSize is (-1, -1) which indicates that wxWindows should generate a default size for the window. + +style = Window style. See wxToolBar for details. + +name = Window name. +""" diff --git a/utils/wxPython/demo/wxTreeCtrl.py b/utils/wxPython/demo/wxTreeCtrl.py new file mode 100644 index 0000000000..a14723b9e4 --- /dev/null +++ b/utils/wxPython/demo/wxTreeCtrl.py @@ -0,0 +1,98 @@ + +from wxPython.wx import * + +#--------------------------------------------------------------------------- + +class TestTreeCtrlPanel(wxPanel): + def __init__(self, parent, log): + wxPanel.__init__(self, parent, -1) + + self.log = log + tID = NewId() + + self.tree = wxTreeCtrl(self, tID) + root = self.tree.AddRoot("The Root Item") + for x in range(15): + child = self.tree.AppendItem(root, "Item %d" % x) + for y in range(5): + last = self.tree.AppendItem(child, "item %d-%s" % (x, chr(ord("a")+y))) + for z in range(5): + self.tree.AppendItem(last, "item %d-%s-%d" % (x, chr(ord("a")+y), z)) + + self.tree.Expand(root) + EVT_TREE_ITEM_EXPANDED (self, tID, self.OnItemExpanded) + EVT_TREE_ITEM_COLLAPSED (self, tID, self.OnItemCollapsed) + EVT_TREE_SEL_CHANGED (self, tID, self.OnSelChanged) + + + def OnSize(self, event): + w,h = self.GetClientSizeTuple() + self.tree.SetDimensions(0, 0, w, h) + + + def OnItemExpanded(self, event): + item = event.GetItem() + self.log.WriteText("OnItemExpanded: %s\n" % self.tree.GetItemText(item)) + + def OnItemCollapsed(self, event): + item = event.GetItem() + self.log.WriteText("OnItemCollapsed: %s\n" % self.tree.GetItemText(item)) + + def OnSelChanged(self, event): + item = event.GetItem() + self.log.WriteText("OnSelChanged: %s\n" % self.tree.GetItemText(item)) + +#--------------------------------------------------------------------------- + +def runTest(frame, nb, log): + win = TestTreeCtrlPanel(nb, log) + return win + +#--------------------------------------------------------------------------- + + + + + + + + + + + + + + + + + + +overview = """\ +A tree control presents information as a hierarchy, with items that may be expanded to show further items. Items in a tree control are referenced by wxTreeItemId handles. + +wxTreeCtrl() +------------------------- + +Default constructor. + +wxTreeCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTR_HAS_BUTTONS, const wxValidator& validator = wxDefaultValidator, const wxString& name = "listCtrl") + +Constructor, creating and showing a tree control. + +Parameters +------------------- + +parent = Parent window. Must not be NULL. + +id = Window identifier. A value of -1 indicates a default value. + +pos = Window position. + +size = Window size. If the default size (-1, -1) is specified then the window is sized appropriately. + +style = Window style. See wxTreeCtrl. + +validator = Window validator. + +name = Window name. +""" diff --git a/utils/wxPython/distrib/SelfInst-README.txt b/utils/wxPython/distrib/SelfInst-README.txt index 5ec99b9e56..812d3446ef 100644 --- a/utils/wxPython/distrib/SelfInst-README.txt +++ b/utils/wxPython/distrib/SelfInst-README.txt @@ -35,6 +35,58 @@ Or you can send mail directly to the list using this address: wxpython-users@starship.python.net +What's new in 2.0b9 +------------------- +Bug fix for ListCtrl in test4.py (Was a missing file... DSM!) + +Bug fix for occassional GPF on Win32 systems upon termination of a +wxPython application. + +Added wxListBox.GetSelections returning selections as a Tuple. + +Added a wxTreeItemData that is able to hold any Python object and be +associated with items in a wxTreeCtrl. Added test pytree.py to show +this feature off. + +Added wxSafeYield function. + +OpenGL Canvas can be optionally compiled in to wxPython. + +Awesome new Demo Framework for showing off wxPython and for learning +how it all works. + +The pre-built Win32 version is no longer distributing the wxWindows +DLL. It is statically linked with the wxWindows library instead. + +Added a couple missing items from the docs. + +Added wxImage, wxImageHandler, wxPNGHandler, wxJPEGHandler, +wxGIFHandler and wxBMPHandler. + + + +What's new in 2.0b8 +------------------- +Support for using Python threads in wxPython apps. + +Several missing methods from various classes. + +Various bug fixes. + + + +What's new in 2.0b7 +------------------- +Added DLG_PNT and DLG_SZE convienience methods to wxWindow class. + +Added missing constructor and other methods for wxMenuItem. + + + +What's new in 2.0b6 +------------------- +Just a quickie update to fix the self-installer to be compatible with +Python 1.5.2b2's Registry settings. What's new in 2.0b5 diff --git a/utils/wxPython/distrib/wxPython.rsp b/utils/wxPython/distrib/wxPython.rsp index 0b8a5ee73f..e452e6aa77 100644 --- a/utils/wxPython/distrib/wxPython.rsp +++ b/utils/wxPython/distrib/wxPython.rsp @@ -1,8 +1,8 @@ wxPython\*.txt -wxPython\tests\*.py -wxPython\tests\bitmaps\*.bmp -wxPython\tests\bitmaps\*.ico +wxPython\demo\*.py +wxPython\demo\bitmaps\*.bmp +wxPython\demo\bitmaps\*.ico @@ -33,4 +33,6 @@ wxPython\src\qt\*.cpp wxPython\src\qt\*.h wxPython\src\qt\*.py +wxPython\SWIG.patches\*.patch + diff --git a/utils/wxPython/distrib/wxPython.wse b/utils/wxPython/distrib/wxPython.wse index 9468334325..7ac423f6ba 100644 --- a/utils/wxPython/distrib/wxPython.wse +++ b/utils/wxPython/distrib/wxPython.wse @@ -17,7 +17,7 @@ item: Global Patch Flags=0000000000001001 Patch Threshold=85 Patch Memory=4000 - EXE Filename=wxPython-2.0b6.exe + EXE Filename=wxPython-2.0b9.exe FTP Cluster Size=20 Per-User Version ID=1 Dialogs Version=6 @@ -191,7 +191,7 @@ end item: End Block end item: Display Graphic - Pathname=e:\Projects\wxPython\distrib\wxPython.BMP + Pathname=e:\Projects\wx\utils\wxPython\distrib\wxPython.BMP X Position=32784 Y Position=16 Flags=0000001010000000 @@ -971,11 +971,6 @@ item: If/While Statement Value=A Flags=00001010 end -item: Install File - Source=e:\Projects\wx\lib\wx200.dll - Destination=%SYS%\wx200.dll - Flags=0000001010010010 -end item: Install File Source=c:\WINNT\System32\Msvcirt.dll Destination=%SYS%\Msvcirt.dll @@ -987,178 +982,63 @@ item: Install File Flags=0000001010000011 end item: Install File - Source=e:\Projects\wxPython\__init__.py - Destination=%MAINDIR%\wxPython\__init__.py + Source=e:\Projects\wx\utils\wxPython\*.py + Destination=%MAINDIR%\wxPython + Description=wxPython shadow class modules Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\cmndlgs.py - Destination=%MAINDIR%\wxPython\cmndlgs.py + Source=e:\Projects\wx\utils\wxPython\*.pyd + Destination=%MAINDIR%\wxPython\ + Description=wxPython extension modules Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\controls2.py - Destination=%MAINDIR%\wxPython\controls2.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\events.py - Destination=%MAINDIR%\wxPython\events.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\frames.py - Destination=%MAINDIR%\wxPython\frames.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\gdi.py - Destination=%MAINDIR%\wxPython\gdi.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\mdi.py - Destination=%MAINDIR%\wxPython\mdi.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\misc.py - Destination=%MAINDIR%\wxPython\misc.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\stattool.py - Destination=%MAINDIR%\wxPython\stattool.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\utils.py - Destination=%MAINDIR%\wxPython\utils.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\windows.py - Destination=%MAINDIR%\wxPython\windows.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\windows2.py - Destination=%MAINDIR%\wxPython\windows2.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\windows3.py - Destination=%MAINDIR%\wxPython\windows3.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\controls.py - Destination=%MAINDIR%\wxPython\controls.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\wx.py - Destination=%MAINDIR%\wxPython\wx.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\wxc.pyd - Destination=%MAINDIR%\wxPython\wxc.pyd - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\distrib\SelfInst-README.txt + Source=e:\Projects\wx\utils\wxPython\distrib\SelfInst-README.txt Destination=%MAINDIR%\wxPython\README.txt + Description=README file Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\tests\test1.py - Destination=%MAINDIR%\wxPython\demo\test1.py + Source=e:\Projects\wx\utils\wxPython\lib\*.py + Destination=%MAINDIR%\wxPython\lib + Description=wxPython Standard Library Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\tests\test2.py - Destination=%MAINDIR%\wxPython\demo\test2.py + Source=e:\Projects\wx\utils\wxPython\demo\*.py + Destination=%MAINDIR%\wxPython\demo + Description=Demos Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\tests\test3.py - Destination=%MAINDIR%\wxPython\demo\test3.py + Source=e:\Projects\wx\utils\wxPython\demo\bitmaps\*.bmp + Destination=%MAINDIR%\wxPython\demo\bitmaps + Description=Demos Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\tests\test4.py - Destination=%MAINDIR%\wxPython\demo\test4.py + Source=e:\Projects\wx\utils\wxPython\demo\bitmaps\*.gif + Destination=%MAINDIR%\wxPython\demo\bitmaps + Description=Demos Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\tests\test5.py - Destination=%MAINDIR%\wxPython\demo\test5.py + Source=e:\Projects\wx\utils\wxPython\demo\bitmaps\*.jpg + Destination=%MAINDIR%\wxPython\demo\bitmaps + Description=Demos Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\tests\test6.py - Destination=%MAINDIR%\wxPython\demo\test6.py + Source=e:\Projects\wx\utils\wxPython\demo\bitmaps\*.png + Destination=%MAINDIR%\wxPython\demo\bitmaps + Description=Demos Flags=0000000010000010 end item: Install File - Source=e:\Projects\wxPython\tests\test7.py - Destination=%MAINDIR%\wxPython\demo\test7.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\wxSlash.py - Destination=%MAINDIR%\wxPython\demo\wxSlash.py - Flags=0000000010000010 -end -item: Install File - Source=E:\PROJECTS\wxPython\tests\wxPlotCanvas.py - Destination=%MAINDIR%\wxPython\demo\wxPlotCanvas.py - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\copy.bmp - Destination=%MAINDIR%\wxPython\demo\bitmaps\copy.bmp - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\mondrian.ico - Destination=%MAINDIR%\wxPython\demo\bitmaps\mondrian.ico - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\new.bmp - Destination=%MAINDIR%\wxPython\demo\bitmaps\new.bmp - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\open.bmp - Destination=%MAINDIR%\wxPython\demo\bitmaps\open.bmp - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\paste.bmp - Destination=%MAINDIR%\wxPython\demo\bitmaps\paste.bmp - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\smiles.ico - Destination=%MAINDIR%\wxPython\demo\bitmaps\smiles.ico - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\tog1.bmp - Destination=%MAINDIR%\wxPython\demo\bitmaps\tog1.bmp - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\test2.bmp - Destination=%MAINDIR%\wxPython\demo\bitmaps\test2.bmp - Flags=0000000010000010 -end -item: Install File - Source=e:\Projects\wxPython\tests\bitmaps\tog2.bmp - Destination=%MAINDIR%\wxPython\demo\bitmaps\tog2.bmp + Source=e:\Projects\wx\utils\wxPython\demo\bitmaps\*.ico + Destination=%MAINDIR%\wxPython\demo\bitmaps + Description=Demos Flags=0000000010000010 end item: End Block @@ -1173,11 +1053,13 @@ end item: Install File Source=e:\projects\wx\docs\html\wx\*.* Destination=%MAINDIR%\wxPython\docs + Description=wxPython documentation Flags=0000000010000010 end item: Install File Source=e:\projects\wx\docs\html\wx\wx.htm Destination=%MAINDIR%\wxPython\docs\index.htm + Description=wxPython documentation Flags=0000000010000010 end item: End Block diff --git a/utils/wxPython/distrib/wxPython.wsm b/utils/wxPython/distrib/wxPython.wsm index b34766c331df1a1dbcc4900cd7a0167ce40f993b..06af71fce4ac046d37a808bee2ba93fda922d730 100644 GIT binary patch literal 5796 zcmb7|Yitx%7>2)E5ESAfqQ)SI0Y*ivP_zV$mv$)^rC4c6N!ZxT&Q7;O=d$k1(yli& z0uoUXK`v5^K%IpmE|(Oo6j4Dyq8Pjoj2JW~cp=E;hlxhf@0}@SjAnbbzn&j`pYxq> z&N+K#YN{$qmOo5XK+V$GUFAIn)3DK(5dI2g93DngGOB=TP7o>MBQ;Z|O{^X{-bc$lSPPFE}0xFdjK7VJw9v=VyzhC(8BV~m=++*2kl|*25e55jI%~lo1 zjx;t!QjVqrD$`EAWkwXkjOlT^D3K<5?S3Tf>_HwA+)dIlousAv(V^9d&dGirBLa&> zi@jmBT4c5CU6YBxxwGmV)pYzpqjd;gvgOY!h`_mnbxGM!{orT~K{LCjfe4&C7>{XQ zou8$Ux~6UUHX?90DP57xIkG?Cqc0o92ch2Z6 zbk|Cx^z4%9MBr{xnyq+)y}J%E+H(44B5>}Q?Z}Q}S-Ka!cLSmW+J50D0nQ!umY|nA z(286Lfa{f?56BMF>4+Sr5#$vd!r zVTfaEIu>2+bM9D7vz??CjZ~?6-4xSyZkt|SI-#Px$Z2wj4)zVva_LNKEk9XsZk5iO zm?rC1=ZP};$`HLOU7qbD5rMl;>vGykId$IbdtQ%eT>sRAV~N1sr}~FKv6H7aYHt}3ig*HzG+jU zHxXDMJ~i+F2TsNWI(D8YCISn@D`d?dy7x?Ezg@6rFcDZFn@CqDRsZ1pCW>^g1)x|>L|}n@V^dj*Pei}^xeglF%WdJtfrawndR1vCv;0$I zZ6hj}z4cl?HNfJAsl1;rSmvftM~PdCI+z75mZtc9eD87OtKA291AxWyyaiH8e<^z1 zEPfJ}uzUAqL|{RS5w$MN=OqaiGbFW`SANf>*w}K%R^FIk zq4bol3zf1AgP(IxT*bF;W}&!$q=ha1ZA|j<)OoZnS_RcqH`bR3ET#(V&0p6*&?oal zA0n`@AnYXl9~WmG31i9OXzC29_LMY8uN=#B0gHL~%}!IwG{=w=-i$)~ zLbO<-hhx2nzETljIUFT)> zXDDKbJB!;27B-agr;c=BGqxXwD4eO`^#&FbX-4M~IrRnNU%3_ih`?fTe%Zdzig%7e za93tKcM~io;LCAWE7He8^nx_s{*~WLzygM-w<7F_VkOc=Q6oWgnuE>KU+u-mea=JT zf8+2hsayJWl>*MgVycaPC7%Wy;5-~wLN$HKq!AYj0p}q}$o%2Xx9sb*{KlOH=V7r8 zzAoCnCVZ=3OvxxBa2^^*wVh($Qc!$xO5l7fR(!NCsR>BH`AIq}$#Ae)`ndg*fkfau zB>q~7Yjs4kc*`_PC)-!t;B(%V*@-yOss>n&wx2EcId4nCWXrOxes9n7&pJ2{i(#3u zq{c7Vnqm?4+jda|&O_9>Vm!?s9DP(Oqw{>&gISXZeE5x7iXEwU3>{yAqq5RaeIfrWSczDn=Rd858_)sm(wiA0j|uX@#QKo zkxL0SC-rKvT(0P|?SR{j@w{FNR!rveM6bU}0b;5D&|hrWiLdp@e-?du3=m8Gy2Zp|dS7Y% zqv4tY5KHC8sq7q(d_C0e0mO2d1*Uj(?TGAK;je1|vD6OuBIlmxh~n@E6}Q9QMSxgZ zJmJhqHro108{LRL%mc(yy~$k5YbL?BKlJ>YVP6d(J}*eliuYyW5wD|d6(ByZ7#Dlk zzmSP%jD_Fhw@)lB%+n7-6vZqRqv8HrfLK~ITf$wvk%@n|yIp)%K>Qz<4!{DIvxBIp Gh4f!Bd_Keg diff --git a/utils/wxPython/distrib/zipit.bat b/utils/wxPython/distrib/zipit.bat index 45f3132b92..17d6b2a906 100755 --- a/utils/wxPython/distrib/zipit.bat +++ b/utils/wxPython/distrib/zipit.bat @@ -11,5 +11,6 @@ copy wxPython\docs\wx.htm wxPython\docs\index.htm zip -r wxPython\wxPython-docs-%1.zip wxPython\docs del /y wxPython\docs\*.* +rmdir wxPython\docs -move /R wxPython\*.zip wxPython\distrib \ No newline at end of file +move /R wxPython\*.zip wxPython\distrib diff --git a/utils/wxPython/lib/.cvsignore b/utils/wxPython/lib/.cvsignore new file mode 100644 index 0000000000..0d20b6487c --- /dev/null +++ b/utils/wxPython/lib/.cvsignore @@ -0,0 +1 @@ +*.pyc diff --git a/utils/wxPython/lib/__init__.py b/utils/wxPython/lib/__init__.py new file mode 100644 index 0000000000..b28b04f643 --- /dev/null +++ b/utils/wxPython/lib/__init__.py @@ -0,0 +1,3 @@ + + + diff --git a/utils/wxPython/lib/dialogs.py b/utils/wxPython/lib/dialogs.py new file mode 100644 index 0000000000..1af300f716 --- /dev/null +++ b/utils/wxPython/lib/dialogs.py @@ -0,0 +1,106 @@ +from wxPython.wx import * +from layoutf import Layoutf +import string + + + +class wxScrolledMessageDialog(wxDialog): + + def __init__(self, parent, msg, caption, pos = None, size = None): + if not pos: + pos = wxDefaultPosition + if not size: + size = wxSize(500,300) + wxDialog.__init__(self, parent, -1, caption, pos, size) + text = wxTextCtrl(self, -1, msg, wxDefaultPosition, + wxDefaultSize, + wxTE_MULTILINE | wxTE_READONLY) + ok = wxButton(self, wxID_OK, "OK") + text.SetConstraints(Layoutf('t=t5#1;b=t5#2;l=l5#1;r=r5#1', (self,ok))) + ok.SetConstraints(Layoutf('b=b5#1;x%w50#1;w!80;h!25', (self,))) + self.SetAutoLayout(TRUE) + + + +class wxMultipleChoiceDialog(wxDialog): + + def __init__(self, parent, msg, title, lst, pos = None, size = None): + if not pos: + pos = wxDefaultPosition + if not size: + size = wxSize(200,200) + wxDialog.__init__(self, parent, -1, title, pos, size) + dc = wxClientDC(self) + height = 0 + for line in string.split(msg,'\n'): + height = height + dc.GetTextExtent(msg)[1] + 4 + stat = wxStaticText(self, -1, msg) + self.lbox = wxListBox(self, 100, wxDefaultPosition, + wxDefaultSize, lst, wxLB_MULTIPLE) + ok = wxButton(self, wxID_OK, "OK") + cancel = wxButton(self, wxID_CANCEL, "Cancel") + stat.SetConstraints(Layoutf('t=t10#1;l=l5#1;r=r5#1;h!%d' % (height,), + (self,))) + self.lbox.SetConstraints(Layoutf('t=b10#2;l=l5#1;r=r5#1;b=t5#3', + (self, stat, ok))) + ok.SetConstraints(Layoutf('b=b5#1;x%w25#1;w!80;h!25', (self,))) + cancel.SetConstraints(Layoutf('b=b5#1;x%w75#1;w!80;h!25', (self,))) + self.SetAutoLayout(TRUE) + self.lst = lst + + def OnSize(self, event): + self.Layout() + + def GetValue(self): + return self.lbox.GetSelections() + + def GetValueString(self): + sel = self.lbox.GetSelections() + val = [] + for i in sel: + val.append(self.lst[i]) + return tuple(val) + +if __name__ == '__main__': + class MyFrame(wxFrame): + def __init__(self): + wxFrame.__init__(self, NULL, -1, "hello", + wxDefaultPosition, wxSize(200,200)) + wxButton(self, 100, "Multiple Test",wxPoint(0,0)) + wxButton(self, 101, "Message Test", wxPoint(0,100)) + EVT_BUTTON(self, 100, self.OnMultipleTest) + EVT_BUTTON(self, 101, self.OnMessageTest) + + def OnMultipleTest(self, event): + self.lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', + 'etc', 'etc..', 'etc...' ] + dlg = wxMultipleChoiceDialog(self, + "Pick some from\n this list\nblabla", + "m.s.d.", self.lst) + if (dlg.ShowModal() == wxID_OK): + print "Selection:", dlg.GetValue(), " -> ", dlg.GetValueString() + + def OnMessageTest(self, event): + import sys; + f = open(sys.argv[0],"r") + msg = f.read() + dlg = wxScrolledMessageDialog(self, msg, "message test") + dlg.ShowModal() + + + class MyApp(wxApp): + def OnInit(self): + frame = MyFrame() + frame.Show(TRUE) + self.SetTopWindow(frame) + return TRUE + + app = MyApp(0) + app.MainLoop() + + + + + + + diff --git a/utils/wxPython/lib/layoutf.py b/utils/wxPython/lib/layoutf.py new file mode 100644 index 0000000000..cbbd7edd9e --- /dev/null +++ b/utils/wxPython/lib/layoutf.py @@ -0,0 +1,262 @@ +from wxPython.wx import wxLayoutConstraints,\ + wxTop, wxLeft, wxBottom, wxRight, \ + wxHeight, wxWidth, wxCentreX, wxCentreY +import re,string + +class Layoutf(wxLayoutConstraints): + """ +The class Layoutf(wxLayoutConstraints) presents a simplification +of the wxLayoutConstraints syntax. The name Layoutf is choosen +because of the similarity with C's printf function. + +Quick Example: + + lc = Layoutf('t=t#1;l=r10#2;r!100;h%h50#1', (self, self.panel)) + +is equivalent to + + lc = wxLayoutContraints() + lc.top.SameAs(self, wxTop) + lc.left.SameAs(self.panel, wxRight, 10) + lc.right.Absolute(100) + lc.height.PercentOf(self, wxHeight, 50) + +Usage: + + You can give a constraint string to the Layoutf constructor, +or use the 'pack' method. The following are equivalent: + + lc = Layoutf('t=t#1;l=r#2;r!100;h%h50#1', (self, self.panel)) + +and + + lc = Layoutf() + lc.pack('t=t#1;l=r#2;r!100;h%h50#1', (self, self.panel)) + + Besides 'pack' there's also 'debug_pack' which does not set +constraints, but prints traditional wxLayoutConstraint calls to +stdout. + + The calls to the Layoutf constructor and pack methods have +the following argument list: + + (constraint_string, objects_tuple) + +Constraint String syntax: + + Constraint directives are separated by semi-colons. You +generally (always?) need four directives to completely describe a +subwindow's location. + + A single directive has either of the following forms: + + 1. [numerical argument] + for example r!100 -> lc.right.Absolute(100) ) + and w* -> lc.width.AsIs() + + 2. [numerical argument] + # + for example t_10#2 (lc.top.Below(, 10) + + 3. + [numerical argument]# + for example w%h50#2 ( lc.width.PercentOf(, + wxHeight, 50) and t=b#1 ( lc.top.SameAs(, + wxBottom) ) + + Which one you need is defined by the +type. The following take type 1 (no object to compare with): + + '!': 'Absolute', '?': 'Unconstrained', '*': 'AsIs' + +These take type 2 (need to be compared with another object) + + '<': 'LeftOf', '>': 'RightOf', '^': 'Above', '_': 'Below' + +These take type 3 (need to be compared to another object +attribute) + + '=': 'SameAs', '%': 'PercentOf' + +For all types, the letter can be any of + + 't': 'top', 'l': 'left', 'b': 'bottom', + 'r': 'right', 'h': 'height', 'w': 'width', + 'x': 'centreX', 'y': 'centreY' + +If the operation takes an (optional) numerical argument, place it +in [numerical argument]. For type 3 directives, the letter can be any of + + 't': 'wxTop', 'l': 'wxLeft', 'b': 'wxBottom' + 'r': 'wxRight', 'h': 'wxHeight', 'w': 'wxWidth', + 'x': 'wxCentreX', 'y': 'wxCentreY' + +Note that these are the same letters as used for , +so you'll only need to remember one set. Finally, the object +whose attribute is refered to, is specified by #, where is the 1-based (stupid, I know, +but I've gotten used to it) index of the object in the +objects_tuple argument. + +Bugs: + +Not entirely happy about the logic in the order of arguments +after the character. + +Not all wxLayoutConstraint methods are included in the +syntax. However, the type 3 directives are generally the most +used. Further excuse: wxWindows layout constraints are at the +time of this writing not documented. + +""" + + attr_d = { 't': 'top', 'l': 'left', 'b': 'bottom', + 'r': 'right', 'h': 'height', 'w': 'width', + 'x': 'centreX', 'y': 'centreY' } + op_d = { '=': 'SameAs', '%': 'PercentOf', '<': 'LeftOf', + '>': 'RightOf', '^': 'Above', '_': 'Below', + '!': 'Absolute', '?': 'Unconstrained', '*': 'AsIs' } + cmp_d = { 't': 'wxTop', 'l': 'wxLeft', 'b': 'wxBottom', + 'r': 'wxRight', 'h': 'wxHeight', 'w': 'wxWidth', + 'x': 'wxCentreX', 'y': 'wxCentreY' } + + rexp1 = re.compile('^\s*([tlrbhwxy])\s*([!\?\*])\s*(\d*)\s*$') + rexp2 = re.compile('^\s*([tlrbhwxy])\s*([=%<>^_])\s*([tlrbhwxy]?)\s*(\d*)\s*#(\d+)\s*$') + + def __init__(self,pstr=None,winlist=None): + wxLayoutConstraints.__init__(self) + if pstr: + self.pack(pstr,winlist) + + def pack(self, pstr, winlist): + pstr = string.lower(pstr) + for item in string.split(pstr,';'): + m = self.rexp1.match(item) + if m: + g = list(m.groups()) + attr = getattr(self, self.attr_d[g[0]]) + func = getattr(attr, self.op_d[g[1]]) + if g[1] == '!': + func(int(g[2])) + else: + func() + continue + m = self.rexp2.match(item) + if not m: raise ValueError + g = list(m.groups()) + attr = getattr(self, self.attr_d[g[0]]) + func = getattr(attr, self.op_d[g[1]]) + if g[3]: g[3] = int(g[3]) + else: g[3] = None; + g[4] = int(g[4]) - 1 + if g[1] in '<>^_': + if g[3]: func(winlist[g[4]], g[3]) + else: func(winlist[g[4]]) + else: + cmp = eval(self.cmp_d[g[2]]) + if g[3]: func(winlist[g[4]], cmp, g[3]) + else: func(winlist[g[4]], cmp) + + def debug_pack(self, pstr, winlist): + pstr = string.lower(pstr) + for item in string.split(pstr,';'): + m = self.rexp1.match(item) + if m: + g = list(m.groups()) + attr = getattr(self, self.attr_d[g[0]]) + func = getattr(attr, self.op_d[g[1]]) + if g[1] == '!': + print "%s.%s.%s(%s)" % \ + ('self',self.attr_d[g[0]],self.op_d[g[1]],g[2]) + else: + print "%s.%s.%s()" % \ + ('self',self.attr_d[g[0]],self.op_d[g[1]]) + continue + m = self.rexp2.match(item) + if not m: raise ValueError + g = list(m.groups()) + if g[3]: g[3] = int(g[3]) + else: g[3] = 0; + g[4] = int(g[4]) - 1 + if g[1] in '<>^_': + if g[3]: print "%s.%s.%s(%s,%d)" % \ + ('self',self.attr_d[g[0]],self.op_d[g[1]],winlist[g[4]], + g[3]) + else: print "%s.%s.%s(%s)" % \ + ('self',self.attr_d[g[0]],self.op_d[g[1]],winlist[g[4]]) + else: + if g[3]: print "%s.%s.%s(%s,%s,%d)" % \ + ('self',self.attr_d[g[0]],self.op_d[g[1]],winlist[g[4]], + self.cmp_d[g[2]],g[3]) + else: print "%s.%s.%s(%s,%s)" % \ + ('self',self.attr_d[g[0]],self.op_d[g[1]],winlist[g[4]], + self.cmp_d[g[2]]) + +if __name__=='__main__': + from wxPython.wx import * + + class TestLayoutf(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) + EVT_BUTTON(self, 101, self.OnAbout) + + self.panelA = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelA.SetBackgroundColour(wxBLUE) + self.panelA.SetConstraints(Layoutf('t=t10#1;l=l10#1;b=b10#1;r%r50#1',(self,))) + + self.panelB = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelB.SetBackgroundColour(wxRED) + self.panelB.SetConstraints(Layoutf('t=t10#1;r=r10#1;b%b30#1;l>10#2', (self,self.panelA))) + + self.panelC = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelC.SetBackgroundColour(wxWHITE) + self.panelC.SetConstraints(Layoutf('t_10#3;r=r10#1;b=b10#1;l>10#2', (self,self.panelA,self.panelB))) + + b = wxButton(self.panelA, 101, ' About: ') + b.SetConstraints(Layoutf('X=X#1;Y=Y#1;h*;w%w50#1', (self.panelA,))) + + b = wxButton(self.panelB, 100, ' Panel B ') + b.SetConstraints(Layoutf('t=t2#1;r=r4#1;h*;w*', (self.panelB,))) + + self.panelD = wxWindow(self.panelC, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER) + self.panelD.SetBackgroundColour(wxGREEN) + self.panelD.SetConstraints(Layoutf('b%h50#1;r%w50#1;h=h#2;w=w#2', (self.panelC, b))) + + b = wxButton(self.panelC, 100, ' Panel C ') + b.SetConstraints(Layoutf('t_#1;l>#1;h*;w*', (self.panelD,))) + + wxStaticText(self.panelD, -1, "Panel D", wxPoint(4, 4)).SetBackgroundColour(wxGREEN) + + def OnButton(self, event): + self.Close(true) + + def OnAbout(self, event): + try: + from dialogs import wxScrolledMessageDialog + msg = wxScrolledMessageDialog(self, Layoutf.__doc__, "about") + msg.ShowModal() + except: + print msg + + def OnCloseWindow(self, event): + self.Destroy() + + class TestApp(wxApp): + def OnInit(self): + frame = TestLayoutf(NULL) + frame.Show(1) + self.SetTopWindow(frame) + return 1 + + app = TestApp(0) + app.MainLoop() + + + + + diff --git a/utils/wxPython/lib/wxPlotCanvas.py b/utils/wxPython/lib/wxPlotCanvas.py new file mode 100644 index 0000000000..58d522252b --- /dev/null +++ b/utils/wxPython/lib/wxPlotCanvas.py @@ -0,0 +1,468 @@ +""" +This is a port of Konrad Hinsen's tkPlotCanvas.py plotting module. +After thinking long and hard I came up with the name "wxPlotCanvas.py". + +This file contains two parts; first the re-usable library stuff, then, after +a "if __name__=='__main__'" test, a simple frame and a few default plots +for testing. + +Harm van der Heijden, feb 1999 + +Original comment follows below: +# This module defines a plot widget for Tk user interfaces. +# It supports only elementary line plots at the moment. +# See the example at the end for documentation... +# +# Written by Konrad Hinsen +# With contributions from RajGopal Srinivasan +# Last revision: 1998-7-28 +# +""" + +from wxPython import wx +import string + +# Not everybody will have Numeric, so let's be cool about it... +try: + import Numeric +except: + # bummer! + d = wx.wxMessageDialog(wx.NULL, + """This module requires the Numeric module, which could not be imported. +It probably is not installed (it's not part of the standard Python +distribution). See the Python site (http://www.python.org) for +information on downloading source or binaries.""", + "Numeric not found") + if d.ShowModal() == wx.wxID_CANCEL: + d = wx.wxMessageDialog(wx.NULL, "I kid you not! Pressing Cancel won't help you!", "Not a joke", wx.wxOK) + d.ShowModal() + import sys + sys.exit() + +# +# Plotting classes... +# +class PolyPoints: + + def __init__(self, points, attr): + self.points = Numeric.array(points) + self.scaled = self.points + self.attributes = {} + for name, value in self._attributes.items(): + try: + value = attr[name] + except KeyError: pass + self.attributes[name] = value + + def boundingBox(self): + return Numeric.minimum.reduce(self.points), \ + Numeric.maximum.reduce(self.points) + + def scaleAndShift(self, scale=1, shift=0): + self.scaled = scale*self.points+shift + + +class PolyLine(PolyPoints): + + def __init__(self, points, **attr): + PolyPoints.__init__(self, points, attr) + + _attributes = {'color': 'black', + 'width': 1} + + def draw(self, dc): + color = self.attributes['color'] + width = self.attributes['width'] + arguments = [] + dc.SetPen(wx.wxPen(wx.wxNamedColour(color), width)) + dc.DrawLines(map(tuple,self.scaled)) + + +class PolyMarker(PolyPoints): + + def __init__(self, points, **attr): + + PolyPoints.__init__(self, points, attr) + + _attributes = {'color': 'black', + 'width': 1, + 'fillcolor': None, + 'size': 2, + 'fillstyle': wx.wxSOLID, + 'outline': 'black', + 'marker': 'circle'} + + def draw(self, dc): + color = self.attributes['color'] + width = self.attributes['width'] + size = self.attributes['size'] + fillcolor = self.attributes['fillcolor'] + fillstyle = self.attributes['fillstyle'] + marker = self.attributes['marker'] + + dc.SetPen(wx.wxPen(wx.wxNamedColour(color),width)) + if fillcolor: + dc.SetBrush(wx.wxBrush(wx.wxNamedColour(fillcolor),fillstyle)) + else: + dc.SetBrush(wx.wxBrush(wx.wxNamedColour('black'), wx.wxTRANSPARENT)) + + self._drawmarkers(dc, self.scaled, marker, size) + + def _drawmarkers(self, dc, coords, marker,size=1): + f = eval('self._' +marker) + for xc, yc in coords: + f(dc, xc, yc, size) + + def _circle(self, dc, xc, yc, size=1): + dc.DrawEllipse(xc-2.5*size,yc-2.5*size,5.*size,5.*size) + + def _dot(self, dc, xc, yc, size=1): + dc.DrawPoint(xc,yc) + + def _square(self, dc, xc, yc, size=1): + dc.DrawRectangle(xc-2.5*size,yc-2.5*size,5.*size,5.*size) + + def _triangle(self, dc, xc, yc, size=1): + dc.DrawPolygon([(-0.5*size*5,0.2886751*size*5), + (0.5*size*5,0.2886751*size*5), + (0.0,-0.577350*size*5)],xc,yc) + + def _triangle_down(self, dc, xc, yc, size=1): + dc.DrawPolygon([(-0.5*size*5,-0.2886751*size*5), + (0.5*size*5,-0.2886751*size*5), + (0.0,0.577350*size*5)],xc,yc) + + def _cross(self, dc, xc, yc, size=1): + dc.DrawLine(xc-2.5*size,yc-2.5*size,xc+2.5*size,yc+2.5*size) + dc.DrawLine(xc-2.5*size,yc+2.5*size,xc+2.5*size,yc-2.5*size) + + def _plus(self, dc, xc, yc, size=1): + dc.DrawLine(xc-2.5*size,yc,xc+2.5*size,yc) + dc.DrawLine(xc,yc-2.5*size,xc,yc+2.5*size) + +class PlotGraphics: + + def __init__(self, objects): + self.objects = objects + + def boundingBox(self): + p1, p2 = self.objects[0].boundingBox() + for o in self.objects[1:]: + p1o, p2o = o.boundingBox() + p1 = Numeric.minimum(p1, p1o) + p2 = Numeric.maximum(p2, p2o) + return p1, p2 + + def scaleAndShift(self, scale=1, shift=0): + for o in self.objects: + o.scaleAndShift(scale, shift) + + def draw(self, canvas): + for o in self.objects: + o.draw(canvas) + + def __len__(self): + return len(self.objects) + + def __getitem__(self, item): + return self.objects[item] + + +class PlotCanvas(wx.wxWindow): + + def __init__(self, parent, id = -1): + wx.wxWindow.__init__(self, parent, id, wx.wxPyDefaultPosition, wx.wxPyDefaultSize) + self.border = (1,1) + self.SetClientSizeWH(400,400) + self.SetBackgroundColour(wx.wxNamedColour("white")) + + wx.EVT_SIZE(self,self.reconfigure) + self._setsize() + self.last_draw = None +# self.font = self._testFont(font) + + def OnPaint(self, event): + pdc = wx.wxPaintDC(self) + if self.last_draw is not None: + apply(self.draw, self.last_draw + (pdc,)) + + def reconfigure(self, event): + (new_width,new_height) = self.GetClientSizeTuple() + if new_width == self.width and new_height == self.height: + return + self._setsize() + # self.redraw() + + def _testFont(self, font): + if font is not None: + bg = self.canvas.cget('background') + try: + item = CanvasText(self.canvas, 0, 0, anchor=NW, + text='0', fill=bg, font=font) + self.canvas.delete(item) + except TclError: + font = None + return font + + def _setsize(self): + (self.width,self.height) = self.GetClientSizeTuple(); + self.plotbox_size = 0.97*Numeric.array([self.width, -self.height]) + xo = 0.5*(self.width-self.plotbox_size[0]) + yo = self.height-0.5*(self.height+self.plotbox_size[1]) + self.plotbox_origin = Numeric.array([xo, yo]) + + def draw(self, graphics, xaxis = None, yaxis = None, dc = None): + if dc == None: dc = wx.wxClientDC(self) + dc.BeginDrawing() + dc.Clear() + self.last_draw = (graphics, xaxis, yaxis) + p1, p2 = graphics.boundingBox() + xaxis = self._axisInterval(xaxis, p1[0], p2[0]) + yaxis = self._axisInterval(yaxis, p1[1], p2[1]) + text_width = [0., 0.] + text_height = [0., 0.] + if xaxis is not None: + p1[0] = xaxis[0] + p2[0] = xaxis[1] + xticks = self._ticks(xaxis[0], xaxis[1]) + bb = dc.GetTextExtent(xticks[0][1]) + text_height[1] = bb[1] + text_width[0] = 0.5*bb[0] + bb = dc.GetTextExtent(xticks[-1][1]) + text_width[1] = 0.5*bb[0] + else: + xticks = None + if yaxis is not None: + p1[1] = yaxis[0] + p2[1] = yaxis[1] + yticks = self._ticks(yaxis[0], yaxis[1]) + for y in yticks: + bb = dc.GetTextExtent(y[1]) + text_width[0] = max(text_width[0],bb[0]) + h = 0.5*bb[1] + text_height[0] = h + text_height[1] = max(text_height[1], h) + else: + yticks = None + text1 = Numeric.array([text_width[0], -text_height[1]]) + text2 = Numeric.array([text_width[1], -text_height[0]]) + scale = (self.plotbox_size-text1-text2) / (p2-p1) + shift = -p1*scale + self.plotbox_origin + text1 + self._drawAxes(dc, xaxis, yaxis, p1, p2, + scale, shift, xticks, yticks) + graphics.scaleAndShift(scale, shift) + graphics.draw(dc) + dc.EndDrawing() + + def _axisInterval(self, spec, lower, upper): + if spec is None: + return None + if spec == 'minimal': + if lower == upper: + return lower-0.5, upper+0.5 + else: + return lower, upper + if spec == 'automatic': + range = upper-lower + if range == 0.: + return lower-0.5, upper+0.5 + log = Numeric.log10(range) + power = Numeric.floor(log) + fraction = log-power + if fraction <= 0.05: + power = power-1 + grid = 10.**power + lower = lower - lower % grid + mod = upper % grid + if mod != 0: + upper = upper - mod + grid + return lower, upper + if type(spec) == type(()): + lower, upper = spec + if lower <= upper: + return lower, upper + else: + return upper, lower + raise ValueError, str(spec) + ': illegal axis specification' + + def _drawAxes(self, dc, xaxis, yaxis, + bb1, bb2, scale, shift, xticks, yticks): + dc.SetPen(wx.wxPen(wx.wxNamedColour('BLACK'),1)) + if xaxis is not None: + lower, upper = xaxis + text = 1 + for y, d in [(bb1[1], -3), (bb2[1], 3)]: + p1 = scale*Numeric.array([lower, y])+shift + p2 = scale*Numeric.array([upper, y])+shift + dc.DrawLine(p1[0],p1[1],p2[0],p2[1]) + for x, label in xticks: + p = scale*Numeric.array([x, y])+shift + dc.DrawLine(p[0],p[1],p[0],p[1]+d) + if text: + dc.DrawText(label,p[0],p[1]) + text = 0 + + if yaxis is not None: + lower, upper = yaxis + text = 1 + h = dc.GetCharHeight() + for x, d in [(bb1[0], -3), (bb2[0], 3)]: + p1 = scale*Numeric.array([x, lower])+shift + p2 = scale*Numeric.array([x, upper])+shift + dc.DrawLine(p1[0],p1[1],p2[0],p2[1]) + for y, label in yticks: + p = scale*Numeric.array([x, y])+shift + dc.DrawLine(p[0],p[1],p[0]-d,p[1]) + if text: + dc.DrawText(label,p[0]-dc.GetTextExtent(label)[0], + p[1]-0.5*h) + text = 0 + + def _ticks(self, lower, upper): + ideal = (upper-lower)/7. + log = Numeric.log10(ideal) + power = Numeric.floor(log) + fraction = log-power + factor = 1. + error = fraction + for f, lf in self._multiples: + e = Numeric.fabs(fraction-lf) + if e < error: + error = e + factor = f + grid = factor * 10.**power + if power > 3 or power < -3: + format = '%+7.0e' + elif power >= 0: + digits = max(1, int(power)) + format = '%' + `digits`+'.0f' + else: + digits = -int(power) + format = '%'+`digits+2`+'.'+`digits`+'f' + ticks = [] + t = -grid*Numeric.floor(-lower/grid) + while t <= upper: + ticks.append(t, format % (t,)) + t = t + grid + return ticks + + _multiples = [(2., Numeric.log10(2.)), (5., Numeric.log10(5.))] + + def redraw(self,dc=None): + if self.last_draw is not None: + apply(self.draw, self.last_draw + (dc,)) + + def clear(self): + self.canvas.delete('all') + +#--------------------------------------------------------------------------- +# if running standalone... +# +# ...a sample implementation using the above +# + + +if __name__ == '__main__': + def _InitObjects(): + # 100 points sin function, plotted as green circles + data1 = 2.*Numeric.pi*Numeric.arange(200)/200. + data1.shape = (100, 2) + data1[:,1] = Numeric.sin(data1[:,0]) + markers1 = PolyMarker(data1, color='green', marker='circle',size=1) + + # 50 points cos function, plotted as red line + data1 = 2.*Numeric.pi*Numeric.arange(100)/100. + data1.shape = (50,2) + data1[:,1] = Numeric.cos(data1[:,0]) + lines = PolyLine(data1, color='red') + + # A few more points... + pi = Numeric.pi + markers2 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.), + (3.*pi/4., -1)], color='blue', + fillcolor='green', marker='cross') + + return PlotGraphics([markers1, lines, markers2]) + + + class AppFrame(wx.wxFrame): + def __init__(self, parent, id, title): + wx.wxFrame.__init__(self, parent, id, title, + wx.wxPyDefaultPosition, wx.wxSize(400, 400)) + + # Now Create the menu bar and items + self.mainmenu = wx.wxMenuBar() + + menu = wx.wxMenu() + menu.Append(200, '&Print...', 'Print the current plot') + wx.EVT_MENU(self, 200, self.OnFilePrint) + menu.Append(209, 'E&xit', 'Enough of this already!') + wx.EVT_MENU(self, 209, self.OnFileExit) + self.mainmenu.Append(menu, '&File') + + menu = wx.wxMenu() + menu.Append(210, '&Draw', 'Draw plots') + wx.EVT_MENU(self,210,self.OnPlotDraw) + menu.Append(211, '&Redraw', 'Redraw plots') + wx.EVT_MENU(self,211,self.OnPlotRedraw) + menu.Append(212, '&Clear', 'Clear canvas') + wx.EVT_MENU(self,212,self.OnPlotClear) + self.mainmenu.Append(menu, '&Plot') + + menu = wx.wxMenu() + menu.Append(220, '&About', 'About this thing...') + wx.EVT_MENU(self, 220, self.OnHelpAbout) + self.mainmenu.Append(menu, '&Help') + + self.SetMenuBar(self.mainmenu) + + # A status bar to tell people what's happening + self.CreateStatusBar(1) + + self.client = PlotCanvas(self) + + def OnFilePrint(self, event): + d = wx.wxMessageDialog(self, +"""As of this writing, printing support in wxPython is shaky at best. +Are you sure you want to do this?""", "Danger!", wx.wxYES_NO) + if d.ShowModal() == wx.wxID_YES: + psdc = wx.wxPostScriptDC("out.ps", wx.TRUE, self) + self.client.redraw(psdc) + + def OnFileExit(self, event): + self.Close() + + def OnPlotDraw(self, event): + self.client.draw(_InitObjects(),'automatic','automatic'); + + def OnPlotRedraw(self,event): + self.client.redraw() + + def OnPlotClear(self,event): + self.client.last_draw = None + dc = wx.wxClientDC(self.client) + dc.Clear() + + def OnHelpAbout(self, event): + about = wx.wxMessageDialog(self, __doc__, "About...", wx.wxOK) + about.ShowModal() + + def OnCloseWindow(self, event): + self.Destroy() + + + class MyApp(wx.wxApp): + def OnInit(self): + frame = AppFrame(wx.NULL, -1, "wxPlotCanvas") + frame.Show(wx.TRUE) + self.SetTopWindow(frame) + return wx.TRUE + + + app = MyApp(0) + app.MainLoop() + + + + +#---------------------------------------------------------------------------- diff --git a/utils/wxPython/src/.cvsignore b/utils/wxPython/src/.cvsignore index 351e1160bd..7cbf6f754f 100644 --- a/utils/wxPython/src/.cvsignore +++ b/utils/wxPython/src/.cvsignore @@ -5,10 +5,12 @@ Setup Setup.save Setup.save config.c +glcanvasc.exp make.bat sedscript templates transfer.zip +utilsc.exp vc50.pdb vc60.pdb wxPython.001 diff --git a/utils/wxPython/src/Makefile.pre.in b/utils/wxPython/src/Makefile.pre.in index 22a18a2af9..670eeccd9e 100644 --- a/utils/wxPython/src/Makefile.pre.in +++ b/utils/wxPython/src/Makefile.pre.in @@ -325,7 +325,7 @@ distclean: clobber # -SWIGFLAGS=-c++ -shadow -python -dnone -D__WXGTK__ +SWIGFLAGS=-c++ -shadow -python -dnone -D__WXGTK__ $(SEPARATE) PYMODULES = $(GENCODEDIR)/wx.py $(GENCODEDIR)/events.py \ @@ -350,6 +350,12 @@ $(GENCODEDIR)/%.py : %.i $(GENCODEDIR)/wx.cpp $(GENCODEDIR)/wx.py : wx.i my_typemaps.i _defs.i _extras.py swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i +ifdef SEPARATE +$(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py : utils.i my_typemaps.i + swig $(SWIGFLAGS) -o $(GENCODEDIR)/utils.cpp utils.i +else +$(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py : utils.i my_typemaps.i _defs.i +endif # define some dependencies $(GENCODEDIR)/windows.cpp $(GENCODEDIR)/windows.py : windows.i my_typemaps.i _defs.i diff --git a/utils/wxPython/src/Setup.in b/utils/wxPython/src/Setup.in index 079d0b8b03..e45d828601 100644 --- a/utils/wxPython/src/Setup.in +++ b/utils/wxPython/src/Setup.in @@ -1,44 +1,47 @@ -# This file gives the details of what is needed to build this extension -# module so the Makefile can be created. +## This file gives the details of what is needed to build this extension +## module so the Makefile can be created. -### -### This file should be created by configure. Currently it is tweaked by hand. -### +## If you have not done "make install" for wxWindows then see Setup.in.linux +## for a more verbose version of this file. *shared* CCC=c++ -WXWIN=../../.. GENCODEDIR=gtk srcdir=$(GENCODEDIR) +WX_CONFIG_CFLAGS=`wx-config --cflags` +WX_CONFIG_LIBS=`wx-config --libs` -# Depending on how your Python was built, you may have to set this -# value to use the C++ driver to link with instead of the default -# C driver. For example: + +## Depending on how your Python was built, you may have to set this +## value to use the C++ driver to link with instead of the default +## C driver. For example: MY_LDSHARED=$(CCC) -shared -# Same as above, but for statically linking Python and wxPython together, -# in other words, if you comment out the *shared* above. If this is the -# case then you should ensure that the main() function is Python's, not -# wxWindows'. You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined -# to force this... +## Same as above, but for statically linking Python and wxPython together, +## in other words, if you comment out the *shared* above. If this is the +## case then you should ensure that the main() function is Python's, not +## wxWindows'. You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined +## to force this... MY_LINKCC=$(CCC) -## Pick one of these, or set your own. This is where the -## wxPython module should be installed. It should be a -## subdirectory named wxPython. +## Pick one of these, or set your own. This is where the wxPython module +## should be installed. It should be a subdirectory named wxPython. TARGETDIR=.. #TARGETDIR=$(BINLIBDEST)/site-packages/wxPython +#TARGETDIR=$(BINLIBDEST)/wxPython +SEPARATE=-DSEPARATE + +utilsc utils.cpp \ + -I. $(WX_CONFIG_CFLAGS) \ + -DSWIG_GLOBAL -DWXP_WITH_THREAD $(SEPARATE) -Xlinker $(WX_CONFIG_LIBS) wxc wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \ mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \ - frames.cpp stattool.cpp utils.cpp windows3.cpp \ - # CFLAGS - -I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \ - -I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \ - #-D__WXDEBUG__ \ - # LFLAGS - -L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \ - -lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11 + frames.cpp stattool.cpp windows3.cpp \ + -I. $(WX_CONFIG_CFLAGS) -I/usr/local/lib/glib/include \ + -DSWIG_GLOBAL -DWXP_WITH_THREAD $(SEPARATE) -Xlinker $(WX_CONFIG_LIBS) + + diff --git a/utils/wxPython/src/Setup.in.linux b/utils/wxPython/src/Setup.in.linux index 079d0b8b03..dc9a0f6c44 100644 --- a/utils/wxPython/src/Setup.in.linux +++ b/utils/wxPython/src/Setup.in.linux @@ -31,13 +31,25 @@ MY_LINKCC=$(CCC) TARGETDIR=.. #TARGETDIR=$(BINLIBDEST)/site-packages/wxPython +SEPARATE=-DSEPARATE wxc wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \ mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \ - frames.cpp stattool.cpp utils.cpp windows3.cpp \ + frames.cpp stattool.cpp windows3.cpp \ # CFLAGS -I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \ -I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \ + -DWXP_WITH_THREAD $(SEPARATE) \ + #-D__WXDEBUG__ \ + # LFLAGS + -L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \ + -lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11 + +utilsc utils.cpp \ + # CFLAGS + -I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \ + -I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \ + -DWXP_WITH_THREAD $(SEPARATE) \ #-D__WXDEBUG__ \ # LFLAGS -L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \ diff --git a/utils/wxPython/src/_defs.i b/utils/wxPython/src/_defs.i index b68646d477..cadfc92b56 100644 --- a/utils/wxPython/src/_defs.i +++ b/utils/wxPython/src/_defs.i @@ -254,6 +254,7 @@ enum { wxSL_SELRANGE, wxSB_HORIZONTAL, wxSB_VERTICAL, + wxST_SIZEGRIP, wxBU_AUTODRAW, wxBU_NOAUTODRAW, wxTR_HAS_BUTTONS, @@ -283,11 +284,6 @@ enum { wxSP_NOBORDER, wxSP_3D, wxSP_BORDER, - wxTAB_MULTILINE, - wxTAB_RIGHTJUSTIFY, - wxTAB_FIXEDWIDTH, - wxTAB_OWNERDRAW, -// wxSB_SIZEGRIP, wxFLOOD_SURFACE, wxFLOOD_BORDER, wxODDEVEN_RULE, @@ -362,6 +358,7 @@ enum { wxID_APPLY, wxID_YES, wxID_NO, + wxID_STATIC, wxBITMAP_TYPE_BMP, wxBITMAP_TYPE_BMP_RESOURCE, wxBITMAP_TYPE_ICO, @@ -380,6 +377,7 @@ enum { wxBITMAP_TYPE_PNG_RESOURCE, wxBITMAP_TYPE_ANY, wxBITMAP_TYPE_RESOURCE, + wxBITMAP_TYPE_JPEG, wxOPEN, wxSAVE, @@ -392,14 +390,14 @@ enum { }; -/// Standard error codes -enum ErrCode -{ - ERR_PARAM = (-4000), - ERR_NODATA, - ERR_CANCEL, - ERR_SUCCESS = 0 -}; +// // Standard error codes +// enum ErrCode +// { +// ERR_PARAM = (-4000), +// ERR_NODATA, +// ERR_CANCEL, +// ERR_SUCCESS = 0 +// }; enum { @@ -576,6 +574,81 @@ typedef enum { } _standard_cursors_t; + +typedef enum { + wxPAPER_NONE, // Use specific dimensions + wxPAPER_LETTER, // Letter, 8 1/2 by 11 inches + wxPAPER_LEGAL, // Legal, 8 1/2 by 14 inches + wxPAPER_A4, // A4 Sheet, 210 by 297 millimeters + wxPAPER_CSHEET, // C Sheet, 17 by 22 inches + wxPAPER_DSHEET, // D Sheet, 22 by 34 inches + wxPAPER_ESHEET, // E Sheet, 34 by 44 inches + wxPAPER_LETTERSMALL, // Letter Small, 8 1/2 by 11 inches + wxPAPER_TABLOID, // Tabloid, 11 by 17 inches + wxPAPER_LEDGER, // Ledger, 17 by 11 inches + wxPAPER_STATEMENT, // Statement, 5 1/2 by 8 1/2 inches + wxPAPER_EXECUTIVE, // Executive, 7 1/4 by 10 1/2 inches + wxPAPER_A3, // A3 sheet, 297 by 420 millimeters + wxPAPER_A4SMALL, // A4 small sheet, 210 by 297 millimeters + wxPAPER_A5, // A5 sheet, 148 by 210 millimeters + wxPAPER_B4, // B4 sheet, 250 by 354 millimeters + wxPAPER_B5, // B5 sheet, 182-by-257-millimeter paper + wxPAPER_FOLIO, // Folio, 8-1/2-by-13-inch paper + wxPAPER_QUARTO, // Quarto, 215-by-275-millimeter paper + wxPAPER_10X14, // 10-by-14-inch sheet + wxPAPER_11X17, // 11-by-17-inch sheet + wxPAPER_NOTE, // Note, 8 1/2 by 11 inches + wxPAPER_ENV_9, // #9 Envelope, 3 7/8 by 8 7/8 inches + wxPAPER_ENV_10, // #10 Envelope, 4 1/8 by 9 1/2 inches + wxPAPER_ENV_11, // #11 Envelope, 4 1/2 by 10 3/8 inches + wxPAPER_ENV_12, // #12 Envelope, 4 3/4 by 11 inches + wxPAPER_ENV_14, // #14 Envelope, 5 by 11 1/2 inches + wxPAPER_ENV_DL, // DL Envelope, 110 by 220 millimeters + wxPAPER_ENV_C5, // C5 Envelope, 162 by 229 millimeters + wxPAPER_ENV_C3, // C3 Envelope, 324 by 458 millimeters + wxPAPER_ENV_C4, // C4 Envelope, 229 by 324 millimeters + wxPAPER_ENV_C6, // C6 Envelope, 114 by 162 millimeters + wxPAPER_ENV_C65, // C65 Envelope, 114 by 229 millimeters + wxPAPER_ENV_B4, // B4 Envelope, 250 by 353 millimeters + wxPAPER_ENV_B5, // B5 Envelope, 176 by 250 millimeters + wxPAPER_ENV_B6, // B6 Envelope, 176 by 125 millimeters + wxPAPER_ENV_ITALY, // Italy Envelope, 110 by 230 millimeters + wxPAPER_ENV_MONARCH, // Monarch Envelope, 3 7/8 by 7 1/2 inches + wxPAPER_ENV_PERSONAL, // 6 3/4 Envelope, 3 5/8 by 6 1/2 inches + wxPAPER_FANFOLD_US, // US Std Fanfold, 14 7/8 by 11 inches + wxPAPER_FANFOLD_STD_GERMAN, // German Std Fanfold, 8 1/2 by 12 inches + wxPAPER_FANFOLD_LGL_GERMAN, // German Legal Fanfold, 8 1/2 by 13 inches + + wxPAPER_ISO_B4, // B4 (ISO) 250 x 353 mm + wxPAPER_JAPANESE_POSTCARD, // Japanese Postcard 100 x 148 mm + wxPAPER_9X11, // 9 x 11 in + wxPAPER_10X11, // 10 x 11 in + wxPAPER_15X11, // 15 x 11 in + wxPAPER_ENV_INVITE, // Envelope Invite 220 x 220 mm + wxPAPER_LETTER_EXTRA, // Letter Extra 9 \275 x 12 in + wxPAPER_LEGAL_EXTRA, // Legal Extra 9 \275 x 15 in + wxPAPER_TABLOID_EXTRA, // Tabloid Extra 11.69 x 18 in + wxPAPER_A4_EXTRA, // A4 Extra 9.27 x 12.69 in + wxPAPER_LETTER_TRANSVERSE, // Letter Transverse 8 \275 x 11 in + wxPAPER_A4_TRANSVERSE, // A4 Transverse 210 x 297 mm + wxPAPER_LETTER_EXTRA_TRANSVERSE, // Letter Extra Transverse 9\275 x 12 in + wxPAPER_A_PLUS, // SuperA/SuperA/A4 227 x 356 mm + wxPAPER_B_PLUS, // SuperB/SuperB/A3 305 x 487 mm + wxPAPER_LETTER_PLUS, // Letter Plus 8.5 x 12.69 in + wxPAPER_A4_PLUS, // A4 Plus 210 x 330 mm + wxPAPER_A5_TRANSVERSE, // A5 Transverse 148 x 210 mm + wxPAPER_B5_TRANSVERSE, // B5 (JIS) Transverse 182 x 257 mm + wxPAPER_A3_EXTRA, // A3 Extra 322 x 445 mm + wxPAPER_A5_EXTRA, // A5 Extra 174 x 235 mm + wxPAPER_B5_EXTRA, // B5 (ISO) Extra 201 x 276 mm + wxPAPER_A2, // A2 420 x 594 mm + wxPAPER_A3_TRANSVERSE, // A3 Transverse 297 x 420 mm + wxPAPER_A3_EXTRA_TRANSVERSE // A3 Extra Transverse 322 x 445 mm + +} wxPaperSize ; + + + #define FALSE 0 #define false 0 #define TRUE 1 @@ -756,7 +829,26 @@ enum wxEventType { ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.13 1999/04/30 03:29:18 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.12.4.2 1999/03/28 06:35:01 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// +// Revision 1.12.4.1 1999/03/27 23:29:13 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// // Revision 1.12 1999/02/27 04:21:58 RD +// // Added missing wxRA_SPECIFY_ROWS, wxRA_SPECIFY_COLS // // Revision 1.11 1999/02/20 09:02:54 RD diff --git a/utils/wxPython/src/_extras.py b/utils/wxPython/src/_extras.py index cb5bf56702..3b2e9366a2 100644 --- a/utils/wxPython/src/_extras.py +++ b/utils/wxPython/src/_extras.py @@ -35,8 +35,9 @@ def _StdWindowCallbacks(win): _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) + _checkForCallback(win, "OnIdle", wxEVT_IDLE) + def _StdFrameCallbacks(win): _StdWindowCallbacks(win) @@ -54,7 +55,7 @@ def _StdDialogCallbacks(win): _checkForCallback(win, "OnCharHook", wxEVT_CHAR_HOOK) -def _StdOnScrollCallback(win): +def _StdOnScrollCallbacks(win): try: cb = getattr(win, "OnScroll") except: pass else: EVT_SCROLL(win, cb) @@ -133,6 +134,9 @@ def EVT_ICONIZE(win, func): def EVT_NAVIGATION_KEY(win, func): win.Connect(-1, -1, wxEVT_NAVIGATION_KEY, func) +def EVT_IDLE(win, func): + win.Connect(-1, -1, wxEVT_IDLE, func) + # Mouse Events def EVT_LEFT_DOWN(win, func): @@ -559,27 +563,32 @@ class wxAcceleratorTable(wxAcceleratorTablePtr): #---------------------------------------------------------------------- -## 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 +## class wxPyStdOutWindow: +## def __init__(self, title = "wxPython: stdout/stderr"): +## self.frame = None +## self.title = title -## def write(self, str): # with this method, -## if not self.isShown: -## self.Show(true) -## self.isShown = true -## self.text.WriteText(str) +## def write(self, str): +## if not self.frame: +## self.frame = wxFrame(NULL, -1, self.title) +## self.text = wxTextCtrl(self.frame, -1, "", wxPoint(0,0), wxDefaultSize, +## wxTE_MULTILINE|wxTE_READONLY) +## self.frame.SetSize(wxSize(450, 300)) +## self.frame.Show(true) +## EVT_CLOSE(self.frame, self.OnCloseWindow) +## self.text.AppendText(str) -## def OnCloseWindow(self, event): # doesn't allow the window to close, just hides it -## self.Show(false) -## self.isShown = false +## def OnCloseWindow(self, event): +## wxBell() +## self.frame.Destroy() +## self.frame = None +## self.text = None +## def close(self): +## if self.frame: +## self.frame.Close(true) + _defRedirect = (wxPlatform == '__WXMSW__') #---------------------------------------------------------------------- @@ -610,20 +619,36 @@ class wxApp(wxPyApp): if filename: sys.stdout = sys.stderr = open(filename, 'a') else: - raise self.error, 'wxPyStdOutWindow not yet implemented.' - #self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow() + #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 + self.stdioWin.close() #---------------------------------------------------------------------------- # # $Log$ +# Revision 1.12 1999/04/30 03:29:18 RD +# wxPython 2.0b9, first phase (win32) +# Added gobs of stuff, see wxPython/README.txt for details +# +# Revision 1.11.4.2 1999/03/28 06:35:01 RD +# +# wxPython 2.0b8 +# Python thread support +# various minor additions +# various minor fixes +# +# Revision 1.11.4.1 1999/03/27 23:29:13 RD +# +# wxPython 2.0b8 +# Python thread support +# various minor additions +# various minor fixes +# # Revision 1.11 1999/02/20 09:02:55 RD # Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a # window handle. If you can get the window handle into the python code, diff --git a/utils/wxPython/src/cmndlgs.i b/utils/wxPython/src/cmndlgs.i index 4a17cfce36..85c55b7f8a 100644 --- a/utils/wxPython/src/cmndlgs.i +++ b/utils/wxPython/src/cmndlgs.i @@ -198,22 +198,17 @@ public: //---------------------------------------------------------------------- -class wxPageSetupData { + +class wxPageSetupDialogData { public: - wxPageSetupData(); - ~wxPageSetupData(); + wxPageSetupDialogData(); + ~wxPageSetupDialogData(); 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(); @@ -221,33 +216,42 @@ public: bool GetEnablePrinter(); bool GetEnableHelp(); bool GetDefaultInfo(); - void SetPaperSize(const wxPoint& size); + wxPoint GetMarginTopLeft(); + wxPoint GetMarginBottomRight(); + wxPoint GetMinMarginTopLeft(); + wxPoint GetMinMarginBottomRight(); + wxPaperSize GetPaperId(); + wxSize GetPaperSize(); + wxPrintData& GetPrintData(); + void SetDefaultInfo(bool flag); + void SetDefaultMinMargins(bool flag); 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); + void SetPaperId(wxPaperSize& id); + void SetPaperSize(const wxSize& size); + void SetPrintData(const wxPrintData& printData); }; class wxPageSetupDialog : public wxDialog { public: - wxPageSetupDialog(wxWindow* parent, wxPageSetupData* data = NULL); + wxPageSetupDialog(wxWindow* parent, wxPageSetupDialogData* data = NULL); %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)" - wxPageSetupData& GetPageSetupData(); + wxPageSetupDialogData& GetPageSetupData(); int ShowModal(); }; //---------------------------------------------------------------------- -class wxPrintData { + +class wxPrintDialogData { public: - wxPrintData(); - ~wxPrintData(); + wxPrintDialogData(); + ~wxPrintDialogData(); void EnableHelp(bool flag); void EnablePageNumbers(bool flag); @@ -259,14 +263,15 @@ public: int GetMaxPage(); int GetMinPage(); int GetNoCopies(); - int GetOrientation(); + wxPrintData& GetPrintData(); + bool GetPrintToFile(); 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 SetPrintData(const wxPrintData& printData); void SetPrintToFile(bool flag); void SetSetupDialog(bool flag); void SetToPage(int page); @@ -275,11 +280,11 @@ public: class wxPrintDialog : public wxDialog { public: - wxPrintDialog(wxWindow* parent, wxPrintData* data = NULL); + wxPrintDialog(wxWindow* parent, wxPrintDialogData* data = NULL); %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)" - wxPrintData& GetPrintData(); + wxPrintDialogData& GetPrintDialogData(); %new wxDC* GetPrintDC(); int ShowModal(); }; @@ -305,7 +310,12 @@ public: ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.9 1999/04/30 03:29:18 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// // Revision 1.8 1998/12/17 14:07:25 RR +// // Removed minor differences between wxMSW and wxGTK // // Revision 1.7 1998/12/15 20:41:14 RD diff --git a/utils/wxPython/src/controls.i b/utils/wxPython/src/controls.i index cc606fec8b..605a9d697c 100644 --- a/utils/wxPython/src/controls.i +++ b/utils/wxPython/src/controls.i @@ -16,6 +16,7 @@ #include "helpers.h" #include #include +#include #ifdef __WXMSW__ #if wxUSE_OWNER_DRAWN @@ -255,7 +256,20 @@ public: int FindString(const wxString& string); // TODO: char* GetClientData(const int n); int GetSelection(); - // TODO: int GetSelections(int **selections); + + // int GetSelections(int **selections); + %addmethods { + PyObject* GetSelections() { + wxArrayInt lst; + self->GetSelections(lst); + PyObject *tup = PyTuple_New(lst.GetCount()); + for(int i=0; iGetItemData(item); + if (data == NULL) { + data = new wxPyTreeItemData(); + self->SetItemData(item, data); + } + return data; + } + + void SetItemData(const wxTreeItemId& item, wxPyTreeItemData* data) { + self->SetItemData(item, data); + } + + // [Get|Set]PyData are short-cuts. Also made somewhat crash-proof by + // automatically creating data classes. + PyObject* GetPyData(const wxTreeItemId& item) { + wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item); + if (data == NULL) { + data = new wxPyTreeItemData(); + self->SetItemData(item, data); + } + return data->GetData(); + } + + void SetPyData(const wxTreeItemId& item, PyObject* obj) { + wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item); + if (data == NULL) { + data = new wxPyTreeItemData(obj); + self->SetItemData(item, data); + } else + data->SetData(obj); + } + } + + bool IsVisible(const wxTreeItemId& item); bool ItemHasChildren(const wxTreeItemId& item); bool IsExpanded(const wxTreeItemId& item); @@ -312,20 +378,20 @@ public: wxTreeItemId AddRoot(const wxString& text, int image = -1, int selectedImage = -1, - wxTreeItemData *data = NULL); + wxPyTreeItemData *data = NULL); wxTreeItemId PrependItem(const wxTreeItemId& parent, const wxString& text, int image = -1, int selectedImage = -1, - wxTreeItemData *data = NULL); + wxPyTreeItemData *data = NULL); wxTreeItemId InsertItem(const wxTreeItemId& parent, const wxTreeItemId& idPrevious, const wxString& text, int image = -1, int selectedImage = -1, - wxTreeItemData *data = NULL); + wxPyTreeItemData *data = NULL); wxTreeItemId AppendItem(const wxTreeItemId& parent, const wxString& text, int image = -1, int selectedImage = -1, - wxTreeItemData *data = NULL); + wxPyTreeItemData *data = NULL); void Delete(const wxTreeItemId& item); void DeleteChildren(const wxTreeItemId& item); @@ -417,7 +483,12 @@ public: ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.17 1999/04/30 03:29:18 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// // Revision 1.16 1999/02/25 07:08:32 RD +// // wxPython version 2.0b5 // // Revision 1.15 1999/02/20 09:02:56 RD diff --git a/utils/wxPython/src/events.i b/utils/wxPython/src/events.i index da2653c594..d8b0bd816d 100644 --- a/utils/wxPython/src/events.i +++ b/utils/wxPython/src/events.i @@ -70,9 +70,8 @@ public: long GetExtraLong(); int GetInt(); int GetSelection(); - char* GetString(); + wxString GetString(); bool IsSelection(); - }; @@ -291,10 +290,32 @@ public: //--------------------------------------------------------------------------- +class wxPyEvent : public wxCommandEvent { +public: + wxPyEvent(wxEventType commandType = wxEVT_NULL, PyObject* userData = Py_None); + ~wxPyEvent(); + void SetUserData(PyObject* userData); + PyObject* GetUserData(); +}; + + + +//--------------------------------------------------------------------------- ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.8 1999/04/30 03:29:18 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.7.4.1 1999/03/27 23:29:14 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// // Revision 1.7 1999/02/20 09:02:57 RD // Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a // window handle. If you can get the window handle into the python code, diff --git a/utils/wxPython/src/gdi.i b/utils/wxPython/src/gdi.i index c4cc53f2c0..85260b6db1 100644 --- a/utils/wxPython/src/gdi.i +++ b/utils/wxPython/src/gdi.i @@ -66,9 +66,10 @@ wxBitmap* wxNoRefBitmap(char* name, long flags); 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. + // 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); } @@ -546,98 +547,3 @@ public: //--------------------------------------------------------------------------- -///////////////////////////////////////////////////////////////////////////// -// -// $Log$ -// Revision 1.14 1999/02/20 10:02:36 RD -// Changes needed to enable wxGTK compatibility. -// -// Revision 1.13 1999/02/20 09:02:58 RD -// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a -// window handle. If you can get the window handle into the python code, -// it should just work... More news on this later. -// -// Added wxImageList, wxToolTip. -// -// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the -// wxRegConfig class. -// -// As usual, some bug fixes, tweaks, etc. -// -// Revision 1.12 1999/01/30 07:30:11 RD -// -// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc. -// -// Various cleanup, tweaks, minor additions, etc. to maintain -// compatibility with the current wxWindows. -// -// Revision 1.11 1998/12/18 15:49:05 RR -// -// wxClipboard now serves the primary selection as well -// wxPython fixes -// warning mesages -// -// Revision 1.10 1998/12/17 18:05:50 RD -// -// wxPython 0.5.2 -// Minor fixes and SWIG code generation for RR's changes. MSW and GTK -// versions are much closer now! -// -// Revision 1.9 1998/12/17 14:07:37 RR -// -// Removed minor differences between wxMSW and wxGTK -// -// Revision 1.8 1998/12/16 22:10:54 RD -// -// Tweaks needed to be able to build wxPython with wxGTK. -// -// Revision 1.7 1998/12/15 20:41:18 RD -// Changed the import semantics from "from wxPython import *" to "from -// wxPython.wx import *" This is for people who are worried about -// namespace pollution, they can use "from wxPython import wx" and then -// prefix all the wxPython identifiers with "wx." -// -// Added wxTaskbarIcon for wxMSW. -// -// Made the events work for wxGrid. -// -// Added wxConfig. -// -// Added wxMiniFrame for wxGTK, (untested.) -// -// Changed many of the args and return values that were pointers to gdi -// objects to references to reflect changes in the wxWindows API. -// -// Other assorted fixes and additions. -// -// Revision 1.6 1998/11/25 08:45:24 RD -// -// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon -// Added events for wxGrid -// Other various fixes and additions -// -// Revision 1.5 1998/10/20 06:43:57 RD -// New wxTreeCtrl wrappers (untested) -// some changes in helpers -// etc. -// -// Revision 1.4 1998/10/02 06:40:38 RD -// -// Version 0.4 of wxPython for MSW. -// -// Revision 1.3 1998/08/18 19:48:16 RD -// more wxGTK compatibility things. -// -// It builds now but there are serious runtime problems... -// -// Revision 1.2 1998/08/15 07:36:35 RD -// - Moved the header in the .i files out of the code that gets put into -// the .cpp files. It caused CVS conflicts because of the RCS ID being -// different each time. -// -// - A few minor fixes. -// -// Revision 1.1 1998/08/09 08:25:50 RD -// Initial version -// -// diff --git a/utils/wxPython/src/glcanvas.i b/utils/wxPython/src/glcanvas.i new file mode 100644 index 0000000000..d032165800 --- /dev/null +++ b/utils/wxPython/src/glcanvas.i @@ -0,0 +1,1093 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: glcanvas.i +// Purpose: SWIG definitions for the OpenGL wxWindows classes +// +// Author: Robin Dunn +// +// Created: 15-Mar-1999 +// RCS-ID: $Id$ +// Copyright: (c) 1998 by Total Control Software +// Licence: wxWindows license +///////////////////////////////////////////////////////////////////////////// + + +%module glcanvas + +%{ +#include "helpers.h" +#include +%} + +//--------------------------------------------------------------------------- + +%include typemaps.i +%include my_typemaps.i + +%extern wx.i +%extern windows.i +%extern windows2.i +%extern windows3.i +%extern frames.i +%extern _defs.i +%extern misc.i +%extern gdi.i +%extern controls.i +%extern events.i + + +%{ +#ifdef SEPARATE + static wxString wxPyEmptyStr(""); + static wxPoint wxPyDefaultPosition(-1, -1); + static wxSize wxPyDefaultSize(-1, -1); +#endif +%} + +%pragma(python) code = "import wx" + +//--------------------------------------------------------------------------- + +class wxPalette; +class wxWindow; +class wxSize; +class wxPoint; + +//--------------------------------------------------------------------------- + +class wxGLContext { +public: + wxGLContext(bool isRGB, wxWindow *win, const wxPalette& palette = wxNullPalette); + ~wxGLContext(); + + void SetCurrent(); + void SetColour(const char *colour); + void SwapBuffers(); + + void SetupPixelFormat(); + void SetupPalette(const wxPalette& palette); + wxPalette CreateDefaultPalette(); + + wxPalette* GetPalette(); + wxWindow* GetWindow(); +}; + +//--------------------------------------------------------------------------- + +class wxGLCanvas : public wxScrolledWindow { +public: + wxGLCanvas(wxWindow *parent, wxWindowID id = -1, + const wxPoint& pos = wxPyDefaultPosition, + const wxSize& size = wxPyDefaultSize, long style = 0, + const char* name = "GLCanvas", + int *attribList = 0, + const wxPalette& palette = wxNullPalette); + + %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)" + + void SetCurrent(); + void SetColour(const char *colour); + void SwapBuffers(); + + wxGLContext* GetContext(); +}; + + +//--------------------------------------------------------------------------- + +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef signed char GLbyte; +typedef short GLshort; +typedef int GLint; +typedef int GLsizei; +typedef unsigned char GLubyte; +typedef unsigned short GLushort; +typedef unsigned int GLuint; +typedef float GLfloat; +typedef float GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void GLvoid; + + +//--------------------------------------------------------------------------- +/* EXT_vertex_array */ +void glArrayElementEXT(GLint i); +void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count); +void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer); +void glGetPointervEXT(GLenum pname, GLvoid* *params); +void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); + +/* EXT_color_subtable */ +void glColorSubtableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table); + +/* EXT_color_table */ +void glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); +void glCopyColorTableEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table); +void glGetColorTableParamaterfvEXT(GLenum target, GLenum pname, GLfloat *params); +void glGetColorTavleParameterivEXT(GLenum target, GLenum pname, GLint *params); + +/* SGI_compiled_vertex_array */ +void glLockArraysSGI(GLint first, GLsizei count); +void glUnlockArraysSGI(); + +/* SGI_cull_vertex */ +void glCullParameterdvSGI(GLenum pname, GLdouble* params); +void glCullParameterfvSGI(GLenum pname, GLfloat* params); + +/* SGI_index_func */ +void glIndexFuncSGI(GLenum func, GLclampf ref); + +/* SGI_index_material */ +void glIndexMaterialSGI(GLenum face, GLenum mode); + +/* WIN_swap_hint */ +void glAddSwapHintRectWin(GLint x, GLint y, GLsizei width, GLsizei height); + + +//---------------------------------------------------------------------- +// From GL.H + +enum { + GL_2D, + GL_2_BYTES, + GL_3D, + GL_3D_COLOR, + GL_3D_COLOR_TEXTURE, + GL_3_BYTES, + GL_4D_COLOR_TEXTURE, + GL_4_BYTES, + GL_ACCUM, + GL_ACCUM_ALPHA_BITS, + GL_ACCUM_BLUE_BITS, + GL_ACCUM_BUFFER_BIT, + GL_ACCUM_CLEAR_VALUE, + GL_ACCUM_GREEN_BITS, + GL_ACCUM_RED_BITS, + GL_ADD, + GL_ALL_ATTRIB_BITS, + GL_ALPHA, + GL_ALPHA12, + GL_ALPHA16, + GL_ALPHA4, + GL_ALPHA8, + GL_ALPHA_BIAS, + GL_ALPHA_BITS, + GL_ALPHA_SCALE, + GL_ALPHA_TEST, + GL_ALPHA_TEST_FUNC, + GL_ALPHA_TEST_REF, + GL_ALWAYS, + GL_AMBIENT, + GL_AMBIENT_AND_DIFFUSE, + GL_AND, + GL_AND_INVERTED, + GL_AND_REVERSE, + GL_ATTRIB_STACK_DEPTH, + GL_AUTO_NORMAL, + GL_AUX0, + GL_AUX1, + GL_AUX2, + GL_AUX3, + GL_AUX_BUFFERS, + GL_BACK, + GL_BACK_LEFT, + GL_BACK_RIGHT, + GL_BGRA_EXT, + GL_BGR_EXT, + GL_BITMAP, + GL_BITMAP_TOKEN, + GL_BLEND, + GL_BLEND_DST, + GL_BLEND_SRC, + GL_BLUE, + GL_BLUE_BIAS, + GL_BLUE_BITS, + GL_BLUE_SCALE, + GL_BYTE, + GL_C3F_V3F, + GL_C4F_N3F_V3F, + GL_C4UB_V2F, + GL_C4UB_V3F, + GL_CCW, + GL_CLAMP, + GL_CLEAR, + GL_CLIENT_ALL_ATTRIB_BITS, + GL_CLIENT_ATTRIB_STACK_DEPTH, + GL_CLIENT_PIXEL_STORE_BIT, + GL_CLIENT_VERTEX_ARRAY_BIT, + GL_CLIP_PLANE0, + GL_CLIP_PLANE1, + GL_CLIP_PLANE2, + GL_CLIP_PLANE3, + GL_CLIP_PLANE4, + GL_CLIP_PLANE5, + GL_COEFF, + GL_COLOR, + GL_COLOR_ARRAY, + GL_COLOR_ARRAY_COUNT_EXT, + GL_COLOR_ARRAY_EXT, + GL_COLOR_ARRAY_POINTER, + GL_COLOR_ARRAY_POINTER_EXT, + GL_COLOR_ARRAY_SIZE, + GL_COLOR_ARRAY_SIZE_EXT, + GL_COLOR_ARRAY_STRIDE, + GL_COLOR_ARRAY_STRIDE_EXT, + GL_COLOR_ARRAY_TYPE, + GL_COLOR_ARRAY_TYPE_EXT, + GL_COLOR_BUFFER_BIT, + GL_COLOR_CLEAR_VALUE, + GL_COLOR_INDEX, + GL_COLOR_INDEX12_EXT, + GL_COLOR_INDEX16_EXT, + GL_COLOR_INDEX1_EXT, + GL_COLOR_INDEX2_EXT, + GL_COLOR_INDEX4_EXT, + GL_COLOR_INDEX8_EXT, + GL_COLOR_INDEXES, + GL_COLOR_LOGIC_OP, + GL_COLOR_MATERIAL, + GL_COLOR_MATERIAL_FACE, + GL_COLOR_MATERIAL_PARAMETER, + GL_COLOR_TABLE_ALPHA_SIZE_EXT, + GL_COLOR_TABLE_BLUE_SIZE_EXT, + GL_COLOR_TABLE_FORMAT_EXT, + GL_COLOR_TABLE_GREEN_SIZE_EXT, + GL_COLOR_TABLE_INTENSITY_SIZE_EXT, + GL_COLOR_TABLE_LUMINANCE_SIZE_EXT, + GL_COLOR_TABLE_RED_SIZE_EXT, + GL_COLOR_TABLE_WIDTH_EXT, + GL_COLOR_WRITEMASK, + GL_COMPILE, + GL_COMPILE_AND_EXECUTE, + GL_CONSTANT_ATTENUATION, + GL_COPY, + GL_COPY_INVERTED, + GL_COPY_PIXEL_TOKEN, + GL_CULL_FACE, + GL_CULL_FACE_MODE, + GL_CURRENT_BIT, + GL_CURRENT_COLOR, + GL_CURRENT_INDEX, + GL_CURRENT_NORMAL, + GL_CURRENT_RASTER_COLOR, + GL_CURRENT_RASTER_DISTANCE, + GL_CURRENT_RASTER_INDEX, + GL_CURRENT_RASTER_POSITION, + GL_CURRENT_RASTER_POSITION_VALID, + GL_CURRENT_RASTER_TEXTURE_COORDS, + GL_CURRENT_TEXTURE_COORDS, + GL_CW, + GL_DECAL, + GL_DECR, + GL_DEPTH, + GL_DEPTH_BIAS, + GL_DEPTH_BITS, + GL_DEPTH_BUFFER_BIT, + GL_DEPTH_CLEAR_VALUE, + GL_DEPTH_COMPONENT, + GL_DEPTH_FUNC, + GL_DEPTH_RANGE, + GL_DEPTH_SCALE, + GL_DEPTH_TEST, + GL_DEPTH_WRITEMASK, + GL_DIFFUSE, + GL_DITHER, + GL_DOMAIN, + GL_DONT_CARE, + GL_DOUBLE, + GL_DOUBLEBUFFER, + GL_DOUBLE_EXT, + GL_DRAW_BUFFER, + GL_DRAW_PIXEL_TOKEN, + GL_DST_ALPHA, + GL_DST_COLOR, + GL_EDGE_FLAG, + GL_EDGE_FLAG_ARRAY, + GL_EDGE_FLAG_ARRAY_COUNT_EXT, + GL_EDGE_FLAG_ARRAY_EXT, + GL_EDGE_FLAG_ARRAY_POINTER, + GL_EDGE_FLAG_ARRAY_POINTER_EXT, + GL_EDGE_FLAG_ARRAY_STRIDE, + GL_EDGE_FLAG_ARRAY_STRIDE_EXT, + GL_EMISSION, + GL_ENABLE_BIT, + GL_EQUAL, + GL_EQUIV, + GL_EVAL_BIT, + GL_EXP, + GL_EXP2, + GL_EXTENSIONS, + GL_EXT_bgra, + GL_EXT_paletted_texture, + GL_EXT_vertex_array, + GL_EYE_LINEAR, + GL_EYE_PLANE, + GL_FALSE, + GL_FASTEST, + GL_FEEDBACK, + GL_FEEDBACK_BUFFER_POINTER, + GL_FEEDBACK_BUFFER_SIZE, + GL_FEEDBACK_BUFFER_TYPE, + GL_FILL, + GL_FLAT, + GL_FLOAT, + GL_FOG, + GL_FOG_BIT, + GL_FOG_COLOR, + GL_FOG_DENSITY, + GL_FOG_END, + GL_FOG_HINT, + GL_FOG_INDEX, + GL_FOG_MODE, + GL_FOG_SPECULAR_TEXTURE_WIN, + GL_FOG_START, + GL_FRONT, + GL_FRONT_AND_BACK, + GL_FRONT_FACE, + GL_FRONT_LEFT, + GL_FRONT_RIGHT, + GL_GEQUAL, + GL_GREATER, + GL_GREEN, + GL_GREEN_BIAS, + GL_GREEN_BITS, + GL_GREEN_SCALE, + GL_HINT_BIT, + GL_INCR, + GL_INDEX_ARRAY, + GL_INDEX_ARRAY_COUNT_EXT, + GL_INDEX_ARRAY_EXT, + GL_INDEX_ARRAY_POINTER, + GL_INDEX_ARRAY_POINTER_EXT, + GL_INDEX_ARRAY_STRIDE, + GL_INDEX_ARRAY_STRIDE_EXT, + GL_INDEX_ARRAY_TYPE, + GL_INDEX_ARRAY_TYPE_EXT, + GL_INDEX_BITS, + GL_INDEX_CLEAR_VALUE, + GL_INDEX_LOGIC_OP, + GL_INDEX_MODE, + GL_INDEX_OFFSET, + GL_INDEX_SHIFT, + GL_INDEX_WRITEMASK, + GL_INT, + GL_INTENSITY, + GL_INTENSITY12, + GL_INTENSITY16, + GL_INTENSITY4, + GL_INTENSITY8, + GL_INVALID_ENUM, + GL_INVALID_OPERATION, + GL_INVALID_VALUE, + GL_INVERT, + GL_KEEP, + GL_LEFT, + GL_LEQUAL, + GL_LESS, + GL_LIGHT0, + GL_LIGHT1, + GL_LIGHT2, + GL_LIGHT3, + GL_LIGHT4, + GL_LIGHT5, + GL_LIGHT6, + GL_LIGHT7, + GL_LIGHTING, + GL_LIGHTING_BIT, + GL_LIGHT_MODEL_AMBIENT, + GL_LIGHT_MODEL_LOCAL_VIEWER, + GL_LIGHT_MODEL_TWO_SIDE, + GL_LINE, + GL_LINEAR, + GL_LINEAR_ATTENUATION, + GL_LINEAR_MIPMAP_LINEAR, + GL_LINEAR_MIPMAP_NEAREST, + GL_LINES, + GL_LINE_BIT, + GL_LINE_LOOP, + GL_LINE_RESET_TOKEN, + GL_LINE_SMOOTH, + GL_LINE_SMOOTH_HINT, + GL_LINE_STIPPLE, + GL_LINE_STIPPLE_PATTERN, + GL_LINE_STIPPLE_REPEAT, + GL_LINE_STRIP, + GL_LINE_TOKEN, + GL_LINE_WIDTH, + GL_LINE_WIDTH_GRANULARITY, + GL_LINE_WIDTH_RANGE, + GL_LIST_BASE, + GL_LIST_BIT, + GL_LIST_INDEX, + GL_LIST_MODE, + GL_LOAD, + GL_LOGIC_OP, + GL_LOGIC_OP_MODE, + GL_LUMINANCE, + GL_LUMINANCE12, + GL_LUMINANCE12_ALPHA12, + GL_LUMINANCE12_ALPHA4, + GL_LUMINANCE16, + GL_LUMINANCE16_ALPHA16, + GL_LUMINANCE4, + GL_LUMINANCE4_ALPHA4, + GL_LUMINANCE6_ALPHA2, + GL_LUMINANCE8, + GL_LUMINANCE8_ALPHA8, + GL_LUMINANCE_ALPHA, + GL_MAP1_COLOR_4, + GL_MAP1_GRID_DOMAIN, + GL_MAP1_GRID_SEGMENTS, + GL_MAP1_INDEX, + GL_MAP1_NORMAL, + GL_MAP1_TEXTURE_COORD_1, + GL_MAP1_TEXTURE_COORD_2, + GL_MAP1_TEXTURE_COORD_3, + GL_MAP1_TEXTURE_COORD_4, + GL_MAP1_VERTEX_3, + GL_MAP1_VERTEX_4, + GL_MAP2_COLOR_4, + GL_MAP2_GRID_DOMAIN, + GL_MAP2_GRID_SEGMENTS, + GL_MAP2_INDEX, + GL_MAP2_NORMAL, + GL_MAP2_TEXTURE_COORD_1, + GL_MAP2_TEXTURE_COORD_2, + GL_MAP2_TEXTURE_COORD_3, + GL_MAP2_TEXTURE_COORD_4, + GL_MAP2_VERTEX_3, + GL_MAP2_VERTEX_4, + GL_MAP_COLOR, + GL_MAP_STENCIL, + GL_MATRIX_MODE, + GL_MAX_ATTRIB_STACK_DEPTH, + GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, + GL_MAX_CLIP_PLANES, + GL_MAX_ELEMENTS_INDICES_WIN, + GL_MAX_ELEMENTS_VERTICES_WIN, + GL_MAX_EVAL_ORDER, + GL_MAX_LIGHTS, + GL_MAX_LIST_NESTING, + GL_MAX_MODELVIEW_STACK_DEPTH, + GL_MAX_NAME_STACK_DEPTH, + GL_MAX_PIXEL_MAP_TABLE, + GL_MAX_PROJECTION_STACK_DEPTH, + GL_MAX_TEXTURE_SIZE, + GL_MAX_TEXTURE_STACK_DEPTH, + GL_MAX_VIEWPORT_DIMS, + GL_MODELVIEW, + GL_MODELVIEW_MATRIX, + GL_MODELVIEW_STACK_DEPTH, + GL_MODULATE, + GL_MULT, + GL_N3F_V3F, + GL_NAME_STACK_DEPTH, + GL_NAND, + GL_NEAREST, + GL_NEAREST_MIPMAP_LINEAR, + GL_NEAREST_MIPMAP_NEAREST, + GL_NEVER, + GL_NICEST, + GL_NONE, + GL_NOOP, + GL_NOR, + GL_NORMALIZE, + GL_NORMAL_ARRAY, + GL_NORMAL_ARRAY_COUNT_EXT, + GL_NORMAL_ARRAY_EXT, + GL_NORMAL_ARRAY_POINTER, + GL_NORMAL_ARRAY_POINTER_EXT, + GL_NORMAL_ARRAY_STRIDE, + GL_NORMAL_ARRAY_STRIDE_EXT, + GL_NORMAL_ARRAY_TYPE, + GL_NORMAL_ARRAY_TYPE_EXT, + GL_NOTEQUAL, + GL_NO_ERROR, + GL_OBJECT_LINEAR, + GL_OBJECT_PLANE, + GL_ONE, + GL_ONE_MINUS_DST_ALPHA, + GL_ONE_MINUS_DST_COLOR, + GL_ONE_MINUS_SRC_ALPHA, + GL_ONE_MINUS_SRC_COLOR, + GL_OR, + GL_ORDER, + GL_OR_INVERTED, + GL_OR_REVERSE, + GL_OUT_OF_MEMORY, + GL_PACK_ALIGNMENT, + GL_PACK_LSB_FIRST, + GL_PACK_ROW_LENGTH, + GL_PACK_SKIP_PIXELS, + GL_PACK_SKIP_ROWS, + GL_PACK_SWAP_BYTES, + GL_PASS_THROUGH_TOKEN, + GL_PERSPECTIVE_CORRECTION_HINT, + GL_PHONG_HINT_WIN, + GL_PHONG_WIN, + GL_PIXEL_MAP_A_TO_A, + GL_PIXEL_MAP_A_TO_A_SIZE, + GL_PIXEL_MAP_B_TO_B, + GL_PIXEL_MAP_B_TO_B_SIZE, + GL_PIXEL_MAP_G_TO_G, + GL_PIXEL_MAP_G_TO_G_SIZE, + GL_PIXEL_MAP_I_TO_A, + GL_PIXEL_MAP_I_TO_A_SIZE, + GL_PIXEL_MAP_I_TO_B, + GL_PIXEL_MAP_I_TO_B_SIZE, + GL_PIXEL_MAP_I_TO_G, + GL_PIXEL_MAP_I_TO_G_SIZE, + GL_PIXEL_MAP_I_TO_I, + GL_PIXEL_MAP_I_TO_I_SIZE, + GL_PIXEL_MAP_I_TO_R, + GL_PIXEL_MAP_I_TO_R_SIZE, + GL_PIXEL_MAP_R_TO_R, + GL_PIXEL_MAP_R_TO_R_SIZE, + GL_PIXEL_MAP_S_TO_S, + GL_PIXEL_MAP_S_TO_S_SIZE, + GL_PIXEL_MODE_BIT, + GL_POINT, + GL_POINTS, + GL_POINT_BIT, + GL_POINT_SIZE, + GL_POINT_SIZE_GRANULARITY, + GL_POINT_SIZE_RANGE, + GL_POINT_SMOOTH, + GL_POINT_SMOOTH_HINT, + GL_POINT_TOKEN, + GL_POLYGON, + GL_POLYGON_BIT, + GL_POLYGON_MODE, + GL_POLYGON_OFFSET_FACTOR, + GL_POLYGON_OFFSET_FILL, + GL_POLYGON_OFFSET_LINE, + GL_POLYGON_OFFSET_POINT, + GL_POLYGON_OFFSET_UNITS, + GL_POLYGON_SMOOTH, + GL_POLYGON_SMOOTH_HINT, + GL_POLYGON_STIPPLE, + GL_POLYGON_STIPPLE_BIT, + GL_POLYGON_TOKEN, + GL_POSITION, + GL_PROJECTION, + GL_PROJECTION_MATRIX, + GL_PROJECTION_STACK_DEPTH, + GL_PROXY_TEXTURE_1D, + GL_PROXY_TEXTURE_2D, + GL_Q, + GL_QUADRATIC_ATTENUATION, + GL_QUADS, + GL_QUAD_STRIP, + GL_R, + GL_R3_G3_B2, + GL_READ_BUFFER, + GL_RED, + GL_RED_BIAS, + GL_RED_BITS, + GL_RED_SCALE, + GL_RENDER, + GL_RENDERER, + GL_RENDER_MODE, + GL_REPEAT, + GL_REPLACE, + GL_RETURN, + GL_RGB, + GL_RGB10, + GL_RGB10_A2, + GL_RGB12, + GL_RGB16, + GL_RGB4, + GL_RGB5, + GL_RGB5_A1, + GL_RGB8, + GL_RGBA, + GL_RGBA12, + GL_RGBA16, + GL_RGBA2, + GL_RGBA4, + GL_RGBA8, + GL_RGBA_MODE, + GL_RIGHT, + GL_S, + GL_SCISSOR_BIT, + GL_SCISSOR_BOX, + GL_SCISSOR_TEST, + GL_SELECT, + GL_SELECTION_BUFFER_POINTER, + GL_SELECTION_BUFFER_SIZE, + GL_SET, + GL_SHADE_MODEL, + GL_SHININESS, + GL_SHORT, + GL_SMOOTH, + GL_SPECULAR, + GL_SPHERE_MAP, + GL_SPOT_CUTOFF, + GL_SPOT_DIRECTION, + GL_SPOT_EXPONENT, + GL_SRC_ALPHA, + GL_SRC_ALPHA_SATURATE, + GL_SRC_COLOR, + GL_STACK_OVERFLOW, + GL_STACK_UNDERFLOW, + GL_STENCIL, + GL_STENCIL_BITS, + GL_STENCIL_BUFFER_BIT, + GL_STENCIL_CLEAR_VALUE, + GL_STENCIL_FAIL, + GL_STENCIL_FUNC, + GL_STENCIL_INDEX, + GL_STENCIL_PASS_DEPTH_FAIL, + GL_STENCIL_PASS_DEPTH_PASS, + GL_STENCIL_REF, + GL_STENCIL_TEST, + GL_STENCIL_VALUE_MASK, + GL_STENCIL_WRITEMASK, + GL_STEREO, + GL_SUBPIXEL_BITS, + GL_T, + GL_T2F_C3F_V3F, + GL_T2F_C4F_N3F_V3F, + GL_T2F_C4UB_V3F, + GL_T2F_N3F_V3F, + GL_T2F_V3F, + GL_T4F_C4F_N3F_V4F, + GL_T4F_V4F, + GL_TEXTURE, + GL_TEXTURE_1D, + GL_TEXTURE_2D, + GL_TEXTURE_ALPHA_SIZE, + GL_TEXTURE_BINDING_1D, + GL_TEXTURE_BINDING_2D, + GL_TEXTURE_BIT, + GL_TEXTURE_BLUE_SIZE, + GL_TEXTURE_BORDER, + GL_TEXTURE_BORDER_COLOR, + GL_TEXTURE_COMPONENTS, + GL_TEXTURE_COORD_ARRAY, + GL_TEXTURE_COORD_ARRAY_COUNT_EXT, + GL_TEXTURE_COORD_ARRAY_EXT, + GL_TEXTURE_COORD_ARRAY_POINTER, + GL_TEXTURE_COORD_ARRAY_POINTER_EXT, + GL_TEXTURE_COORD_ARRAY_SIZE, + GL_TEXTURE_COORD_ARRAY_SIZE_EXT, + GL_TEXTURE_COORD_ARRAY_STRIDE, + GL_TEXTURE_COORD_ARRAY_STRIDE_EXT, + GL_TEXTURE_COORD_ARRAY_TYPE, + GL_TEXTURE_COORD_ARRAY_TYPE_EXT, + GL_TEXTURE_ENV, + GL_TEXTURE_ENV_COLOR, + GL_TEXTURE_ENV_MODE, + GL_TEXTURE_GEN_MODE, + GL_TEXTURE_GEN_Q, + GL_TEXTURE_GEN_R, + GL_TEXTURE_GEN_S, + GL_TEXTURE_GEN_T, + GL_TEXTURE_GREEN_SIZE, + GL_TEXTURE_HEIGHT, + GL_TEXTURE_INTENSITY_SIZE, + GL_TEXTURE_INTERNAL_FORMAT, + GL_TEXTURE_LUMINANCE_SIZE, + GL_TEXTURE_MAG_FILTER, + GL_TEXTURE_MATRIX, + GL_TEXTURE_MIN_FILTER, + GL_TEXTURE_PRIORITY, + GL_TEXTURE_RED_SIZE, + GL_TEXTURE_RESIDENT, + GL_TEXTURE_STACK_DEPTH, + GL_TEXTURE_WIDTH, + GL_TEXTURE_WRAP_S, + GL_TEXTURE_WRAP_T, + GL_TRANSFORM_BIT, + GL_TRIANGLES, + GL_TRIANGLE_FAN, + GL_TRIANGLE_STRIP, + GL_TRUE, + GL_UNPACK_ALIGNMENT, + GL_UNPACK_LSB_FIRST, + GL_UNPACK_ROW_LENGTH, + GL_UNPACK_SKIP_PIXELS, + GL_UNPACK_SKIP_ROWS, + GL_UNPACK_SWAP_BYTES, + GL_UNSIGNED_BYTE, + GL_UNSIGNED_INT, + GL_UNSIGNED_SHORT, + GL_V2F, + GL_V3F, + GL_VENDOR, + GL_VERSION, + GL_VERTEX_ARRAY, + GL_VERTEX_ARRAY_COUNT_EXT, + GL_VERTEX_ARRAY_EXT, + GL_VERTEX_ARRAY_POINTER, + GL_VERTEX_ARRAY_POINTER_EXT, + GL_VERTEX_ARRAY_SIZE, + GL_VERTEX_ARRAY_SIZE_EXT, + GL_VERTEX_ARRAY_STRIDE, + GL_VERTEX_ARRAY_STRIDE_EXT, + GL_VERTEX_ARRAY_TYPE, + GL_VERTEX_ARRAY_TYPE_EXT, + GL_VIEWPORT, + GL_VIEWPORT_BIT, + GL_WIN_draw_range_elements, + GL_WIN_swap_hint, + GL_XOR, + GL_ZERO, + GL_ZOOM_X, + GL_ZOOM_Y, +}; + + +void glAccum (GLenum op, GLfloat value); +void glAlphaFunc (GLenum func, GLclampf ref); +GLboolean glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences); +void glArrayElement (GLint i); +void glBegin (GLenum mode); +void glBindTexture (GLenum target, GLuint texture); +void glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); +void glBlendFunc (GLenum sfactor, GLenum dfactor); +void glCallList (GLuint list); +void glCallLists (GLsizei n, GLenum type, const GLvoid *lists); +void glClear (GLbitfield mask); +void glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void glClearDepth (GLclampd depth); +void glClearIndex (GLfloat c); +void glClearStencil (GLint s); +void glClipPlane (GLenum plane, const GLdouble *equation); +void glColor3b (GLbyte red, GLbyte green, GLbyte blue); +void glColor3bv (const GLbyte *v); +void glColor3d (GLdouble red, GLdouble green, GLdouble blue); +void glColor3dv (const GLdouble *v); +void glColor3f (GLfloat red, GLfloat green, GLfloat blue); +void glColor3fv (const GLfloat *v); +void glColor3i (GLint red, GLint green, GLint blue); +void glColor3iv (const GLint *v); +void glColor3s (GLshort red, GLshort green, GLshort blue); +void glColor3sv (const GLshort *v); +void glColor3ub (GLubyte red, GLubyte green, GLubyte blue); +void glColor3ubv (const GLubyte *v); +void glColor3ui (GLuint red, GLuint green, GLuint blue); +void glColor3uiv (const GLuint *v); +void glColor3us (GLushort red, GLushort green, GLushort blue); +void glColor3usv (const GLushort *v); +void glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void glColor4bv (const GLbyte *v); +void glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void glColor4dv (const GLdouble *v); +void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glColor4fv (const GLfloat *v); +void glColor4i (GLint red, GLint green, GLint blue, GLint alpha); +void glColor4iv (const GLint *v); +void glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha); +void glColor4sv (const GLshort *v); +void glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void glColor4ubv (const GLubyte *v); +void glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha); +void glColor4uiv (const GLuint *v); +void glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha); +void glColor4usv (const GLushort *v); +void glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glColorMaterial (GLenum face, GLenum mode); +void glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +void glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +void glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCullFace (GLenum mode); +void glDeleteLists (GLuint list, GLsizei range); +void glDeleteTextures (GLsizei n, const GLuint *textures); +void glDepthFunc (GLenum func); +void glDepthMask (GLboolean flag); +void glDepthRange (GLclampd zNear, GLclampd zFar); +void glDisable (GLenum cap); +void glDisableClientState (GLenum array); +void glDrawArrays (GLenum mode, GLint first, GLsizei count); +void glDrawBuffer (GLenum mode); +void glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); +void glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +void glEdgeFlag (GLboolean flag); +void glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer); +void glEdgeFlagv (const GLboolean *flag); +void glEnable (GLenum cap); +void glEnableClientState (GLenum array); +void glEnd (void); +void glEndList (void); +void glEvalCoord1d (GLdouble u); +void glEvalCoord1dv (const GLdouble *u); +void glEvalCoord1f (GLfloat u); +void glEvalCoord1fv (const GLfloat *u); +void glEvalCoord2d (GLdouble u, GLdouble v); +void glEvalCoord2dv (const GLdouble *u); +void glEvalCoord2f (GLfloat u, GLfloat v); +void glEvalCoord2fv (const GLfloat *u); +void glEvalMesh1 (GLenum mode, GLint i1, GLint i2); +void glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void glEvalPoint1 (GLint i); +void glEvalPoint2 (GLint i, GLint j); +void glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer); +void glFinish (void); +void glFlush (void); +void glFogf (GLenum pname, GLfloat param); +void glFogfv (GLenum pname, const GLfloat *params); +void glFogi (GLenum pname, GLint param); +void glFogiv (GLenum pname, const GLint *params); +void glFrontFace (GLenum mode); +void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLuint glGenLists (GLsizei range); +void glGenTextures (GLsizei n, GLuint *textures); +void glGetBooleanv (GLenum pname, GLboolean *params); +void glGetClipPlane (GLenum plane, GLdouble *equation); +void glGetDoublev (GLenum pname, GLdouble *params); +GLenum glGetError (void); +void glGetFloatv (GLenum pname, GLfloat *params); +void glGetIntegerv (GLenum pname, GLint *params); +void glGetLightfv (GLenum light, GLenum pname, GLfloat *params); +void glGetLightiv (GLenum light, GLenum pname, GLint *params); +void glGetMapdv (GLenum target, GLenum query, GLdouble *v); +void glGetMapfv (GLenum target, GLenum query, GLfloat *v); +void glGetMapiv (GLenum target, GLenum query, GLint *v); +void glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params); +void glGetMaterialiv (GLenum face, GLenum pname, GLint *params); +void glGetPixelMapfv (GLenum map, GLfloat *values); +void glGetPixelMapuiv (GLenum map, GLuint *values); +void glGetPixelMapusv (GLenum map, GLushort *values); +void glGetPointerv (GLenum pname, GLvoid* *params); +void glGetPolygonStipple (GLubyte *mask); +const GLubyte * glGetString (GLenum name); +void glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params); +void glGetTexEnviv (GLenum target, GLenum pname, GLint *params); +void glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params); +void glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params); +void glGetTexGeniv (GLenum coord, GLenum pname, GLint *params); +void glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); +void glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params); +void glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params); +void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params); +void glGetTexParameteriv (GLenum target, GLenum pname, GLint *params); +void glHint (GLenum target, GLenum mode); +void glIndexMask (GLuint mask); +void glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer); +void glIndexd (GLdouble c); +void glIndexdv (const GLdouble *c); +void glIndexf (GLfloat c); +void glIndexfv (const GLfloat *c); +void glIndexi (GLint c); +void glIndexiv (const GLint *c); +void glIndexs (GLshort c); +void glIndexsv (const GLshort *c); +void glIndexub (GLubyte c); +void glIndexubv (const GLubyte *c); +void glInitNames (void); +void glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer); +GLboolean glIsEnabled (GLenum cap); +GLboolean glIsList (GLuint list); +GLboolean glIsTexture (GLuint texture); +void glLightModelf (GLenum pname, GLfloat param); +void glLightModelfv (GLenum pname, const GLfloat *params); +void glLightModeli (GLenum pname, GLint param); +void glLightModeliv (GLenum pname, const GLint *params); +void glLightf (GLenum light, GLenum pname, GLfloat param); +void glLightfv (GLenum light, GLenum pname, const GLfloat *params); +void glLighti (GLenum light, GLenum pname, GLint param); +void glLightiv (GLenum light, GLenum pname, const GLint *params); +void glLineStipple (GLint factor, GLushort pattern); +void glLineWidth (GLfloat width); +void glListBase (GLuint base); +void glLoadIdentity (void); +void glLoadMatrixd (const GLdouble *m); +void glLoadMatrixf (const GLfloat *m); +void glLoadName (GLuint name); +void glLogicOp (GLenum opcode); +void glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); +void glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); +void glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); +void glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); +void glMapGrid1d (GLint un, GLdouble u1, GLdouble u2); +void glMapGrid1f (GLint un, GLfloat u1, GLfloat u2); +void glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void glMaterialf (GLenum face, GLenum pname, GLfloat param); +void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params); +void glMateriali (GLenum face, GLenum pname, GLint param); +void glMaterialiv (GLenum face, GLenum pname, const GLint *params); +void glMatrixMode (GLenum mode); +void glMultMatrixd (const GLdouble *m); +void glMultMatrixf (const GLfloat *m); +void glNewList (GLuint list, GLenum mode); +void glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz); +void glNormal3bv (const GLbyte *v); +void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz); +void glNormal3dv (const GLdouble *v); +void glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz); +void glNormal3fv (const GLfloat *v); +void glNormal3i (GLint nx, GLint ny, GLint nz); +void glNormal3iv (const GLint *v); +void glNormal3s (GLshort nx, GLshort ny, GLshort nz); +void glNormal3sv (const GLshort *v); +void glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer); +void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void glPassThrough (GLfloat token); +void glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values); +void glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values); +void glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values); +void glPixelStoref (GLenum pname, GLfloat param); +void glPixelStorei (GLenum pname, GLint param); +void glPixelTransferf (GLenum pname, GLfloat param); +void glPixelTransferi (GLenum pname, GLint param); +void glPixelZoom (GLfloat xfactor, GLfloat yfactor); +void glPointSize (GLfloat size); +void glPolygonMode (GLenum face, GLenum mode); +void glPolygonOffset (GLfloat factor, GLfloat units); +void glPolygonStipple (const GLubyte *mask); +void glPopAttrib (void); +void glPopClientAttrib (void); +void glPopMatrix (void); +void glPopName (void); +void glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities); +void glPushAttrib (GLbitfield mask); +void glPushClientAttrib (GLbitfield mask); +void glPushMatrix (void); +void glPushName (GLuint name); +void glRasterPos2d (GLdouble x, GLdouble y); +void glRasterPos2dv (const GLdouble *v); +void glRasterPos2f (GLfloat x, GLfloat y); +void glRasterPos2fv (const GLfloat *v); +void glRasterPos2i (GLint x, GLint y); +void glRasterPos2iv (const GLint *v); +void glRasterPos2s (GLshort x, GLshort y); +void glRasterPos2sv (const GLshort *v); +void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z); +void glRasterPos3dv (const GLdouble *v); +void glRasterPos3f (GLfloat x, GLfloat y, GLfloat z); +void glRasterPos3fv (const GLfloat *v); +void glRasterPos3i (GLint x, GLint y, GLint z); +void glRasterPos3iv (const GLint *v); +void glRasterPos3s (GLshort x, GLshort y, GLshort z); +void glRasterPos3sv (const GLshort *v); +void glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void glRasterPos4dv (const GLdouble *v); +void glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void glRasterPos4fv (const GLfloat *v); +void glRasterPos4i (GLint x, GLint y, GLint z, GLint w); +void glRasterPos4iv (const GLint *v); +void glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w); +void glRasterPos4sv (const GLshort *v); +void glReadBuffer (GLenum mode); +void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); +void glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void glRectdv (const GLdouble *v1, const GLdouble *v2); +void glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void glRectfv (const GLfloat *v1, const GLfloat *v2); +void glRecti (GLint x1, GLint y1, GLint x2, GLint y2); +void glRectiv (const GLint *v1, const GLint *v2); +void glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void glRectsv (const GLshort *v1, const GLshort *v2); +GLint glRenderMode (GLenum mode); +void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void glScaled (GLdouble x, GLdouble y, GLdouble z); +void glScalef (GLfloat x, GLfloat y, GLfloat z); +void glScissor (GLint x, GLint y, GLsizei width, GLsizei height); +void glSelectBuffer (GLsizei size, GLuint *buffer); +void glShadeModel (GLenum mode); +void glStencilFunc (GLenum func, GLint ref, GLuint mask); +void glStencilMask (GLuint mask); +void glStencilOp (GLenum fail, GLenum zfail, GLenum zpass); +void glTexCoord1d (GLdouble s); +void glTexCoord1dv (const GLdouble *v); +void glTexCoord1f (GLfloat s); +void glTexCoord1fv (const GLfloat *v); +void glTexCoord1i (GLint s); +void glTexCoord1iv (const GLint *v); +void glTexCoord1s (GLshort s); +void glTexCoord1sv (const GLshort *v); +void glTexCoord2d (GLdouble s, GLdouble t); +void glTexCoord2dv (const GLdouble *v); +void glTexCoord2f (GLfloat s, GLfloat t); +void glTexCoord2fv (const GLfloat *v); +void glTexCoord2i (GLint s, GLint t); +void glTexCoord2iv (const GLint *v); +void glTexCoord2s (GLshort s, GLshort t); +void glTexCoord2sv (const GLshort *v); +void glTexCoord3d (GLdouble s, GLdouble t, GLdouble r); +void glTexCoord3dv (const GLdouble *v); +void glTexCoord3f (GLfloat s, GLfloat t, GLfloat r); +void glTexCoord3fv (const GLfloat *v); +void glTexCoord3i (GLint s, GLint t, GLint r); +void glTexCoord3iv (const GLint *v); +void glTexCoord3s (GLshort s, GLshort t, GLshort r); +void glTexCoord3sv (const GLshort *v); +void glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void glTexCoord4dv (const GLdouble *v); +void glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void glTexCoord4fv (const GLfloat *v); +void glTexCoord4i (GLint s, GLint t, GLint r, GLint q); +void glTexCoord4iv (const GLint *v); +void glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q); +void glTexCoord4sv (const GLshort *v); +void glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +void glTexEnvf (GLenum target, GLenum pname, GLfloat param); +void glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params); +void glTexEnvi (GLenum target, GLenum pname, GLint param); +void glTexEnviv (GLenum target, GLenum pname, const GLint *params); +void glTexGend (GLenum coord, GLenum pname, GLdouble param); +void glTexGendv (GLenum coord, GLenum pname, const GLdouble *params); +void glTexGenf (GLenum coord, GLenum pname, GLfloat param); +void glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params); +void glTexGeni (GLenum coord, GLenum pname, GLint param); +void glTexGeniv (GLenum coord, GLenum pname, const GLint *params); +void glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +void glTexParameterf (GLenum target, GLenum pname, GLfloat param); +void glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params); +void glTexParameteri (GLenum target, GLenum pname, GLint param); +void glTexParameteriv (GLenum target, GLenum pname, const GLint *params); +void glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); +void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +void glTranslated (GLdouble x, GLdouble y, GLdouble z); +void glTranslatef (GLfloat x, GLfloat y, GLfloat z); +void glVertex2d (GLdouble x, GLdouble y); +void glVertex2dv (const GLdouble *v); +void glVertex2f (GLfloat x, GLfloat y); +void glVertex2fv (const GLfloat *v); +void glVertex2i (GLint x, GLint y); +void glVertex2iv (const GLint *v); +void glVertex2s (GLshort x, GLshort y); +void glVertex2sv (const GLshort *v); +void glVertex3d (GLdouble x, GLdouble y, GLdouble z); +void glVertex3dv (const GLdouble *v); +void glVertex3f (GLfloat x, GLfloat y, GLfloat z); +void glVertex3fv (const GLfloat *v); +void glVertex3i (GLint x, GLint y, GLint z); +void glVertex3iv (const GLint *v); +void glVertex3s (GLshort x, GLshort y, GLshort z); +void glVertex3sv (const GLshort *v); +void glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void glVertex4dv (const GLdouble *v); +void glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void glVertex4fv (const GLfloat *v); +void glVertex4i (GLint x, GLint y, GLint z, GLint w); +void glVertex4iv (const GLint *v); +void glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w); +void glVertex4sv (const GLshort *v); +void glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +void glViewport (GLint x, GLint y, GLsizei width, GLsizei height); + +//--------------------------------------------------------------------------- +///////////////////////////////////////////////////////////////////////////// +// +// $Log$ +// Revision 1.1 1999/04/30 03:29:18 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// diff --git a/utils/wxPython/src/glcanvasc.def b/utils/wxPython/src/glcanvasc.def new file mode 100644 index 0000000000..8be1ced94e --- /dev/null +++ b/utils/wxPython/src/glcanvasc.def @@ -0,0 +1,2 @@ +EXPORTS + initglcanvasc diff --git a/utils/wxPython/src/helpers.cpp b/utils/wxPython/src/helpers.cpp index 3dc40d7362..2f5eabfb67 100644 --- a/utils/wxPython/src/helpers.cpp +++ b/utils/wxPython/src/helpers.cpp @@ -28,6 +28,7 @@ #endif #include + //--------------------------------------------------------------------------- //wxHashTable* wxPyWindows = NULL; @@ -62,6 +63,15 @@ BOOL WINAPI DllMain( wxPyApp *wxPythonApp = NULL; // Global instance of application object +wxPyApp::wxPyApp() { +// printf("**** ctor\n"); +} + +wxPyApp::~wxPyApp() { +// printf("**** dtor\n"); +} + + // This one isn't acutally called... See __wxStart() bool wxPyApp::OnInit(void) { return false; @@ -139,7 +149,9 @@ void __wxPreStart() } - +#ifdef WXP_WITH_THREAD +static PyThreadState *event_tstate = NULL; +#endif static char* __nullArgv[1] = { 0 }; // Start the user application, user App's OnInit method is a parameter here @@ -150,6 +162,9 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args) PyObject* result; long bResult; +#ifdef WXP_WITH_THREAD + event_tstate = PyThreadState_Get(); +#endif if (!PyArg_ParseTuple(args, "O", &onInitFunc)) return NULL; @@ -162,13 +177,18 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args) // This is the next part of the wxEntry functionality... wxPythonApp->argc = 0; - wxPythonApp->argv = __nullArgv; + wxPythonApp->argv = NULL; wxPythonApp->OnInitGui(); // Call the Python App's OnInit function arglist = PyTuple_New(0); + + // Py_END_ALLOW_THREADS; **** __wxStart was called from Python, + // should already have the lock result = PyEval_CallObject(onInitFunc, arglist); + // Py_BEGIN_ALLOW_THREADS; + if (!result) { PyErr_Print(); exit(1); @@ -260,6 +280,27 @@ PyObject* wxPyConstructObject(void* ptr, char* className) } + +wxPyCallback::wxPyCallback(PyObject* func) { + m_func = func; + Py_INCREF(m_func); +} + +wxPyCallback::~wxPyCallback() { +#ifdef WXP_WITH_THREAD + PyEval_RestoreThread(event_tstate); +#endif + + Py_DECREF(m_func); + +#ifdef WXP_WITH_THREAD + PyEval_SaveThread(); +#endif +} + + + + // This function is used for all events destined for Python event handlers. void wxPyCallback::EventThunker(wxEvent& event) { wxPyCallback* cb = (wxPyCallback*)event.m_callbackUserData; @@ -268,6 +309,10 @@ void wxPyCallback::EventThunker(wxEvent& event) { PyObject* arg; PyObject* tuple; + +#ifdef WXP_WITH_THREAD + PyEval_RestoreThread(event_tstate); +#endif arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName()); tuple = PyTuple_New(1); @@ -280,6 +325,9 @@ void wxPyCallback::EventThunker(wxEvent& event) { } else { PyErr_Print(); } +#ifdef WXP_WITH_THREAD + PyEval_SaveThread(); +#endif } @@ -301,6 +349,9 @@ wxPyMenu::~wxPyMenu() { void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) { +#ifdef WXP_WITH_THREAD + PyEval_RestoreThread(event_tstate); +#endif PyObject* evtobj = wxPyConstructObject((void*)&evt, "wxCommandEvent"); PyObject* menuobj = wxPyConstructObject((void*)&menu, "wxMenu"); if (PyErr_Occurred()) { @@ -316,6 +367,9 @@ void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) { PyObject* res = PyEval_CallObject(func, args); Py_DECREF(args); Py_XDECREF(res); /* In case res is a NULL pointer */ +#ifdef WXP_WITH_THREAD + PyEval_SaveThread(); +#endif } @@ -331,6 +385,9 @@ wxPyTimer::~wxPyTimer() { } void wxPyTimer::Notify() { +#ifdef WXP_WITH_THREAD + PyEval_RestoreThread(event_tstate); +#endif PyObject* result; PyObject* args = Py_BuildValue("()"); @@ -342,9 +399,49 @@ void wxPyTimer::Notify() { } else { PyErr_Print(); } +#ifdef WXP_WITH_THREAD + PyEval_SaveThread(); +#endif } +//---------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxCommandEvent) + +wxPyEvent::wxPyEvent(wxEventType commandType, PyObject* userData) + : wxCommandEvent(commandType), m_userData(Py_None) +{ + m_userData = userData; + if (m_userData != Py_None) { + Py_INCREF(m_userData); + } +} + + +wxPyEvent::~wxPyEvent() { + if (m_userData != Py_None) { + Py_DECREF(m_userData); + m_userData = Py_None; + } +} + + +void wxPyEvent::SetUserData(PyObject* userData) { + if (m_userData != Py_None) { + Py_DECREF(m_userData); + m_userData = Py_None; + } + m_userData = userData; + if (m_userData != Py_None) { + Py_INCREF(m_userData); + } +} + + +PyObject* wxPyEvent::GetUserData() { + return m_userData; +} //---------------------------------------------------------------------- //---------------------------------------------------------------------- @@ -584,6 +681,17 @@ wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) { ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.20 1999/04/30 03:29:18 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.19.4.1 1999/03/27 23:29:14 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// // Revision 1.19 1999/02/20 09:02:59 RD // Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a // window handle. If you can get the window handle into the python code, diff --git a/utils/wxPython/src/helpers.h b/utils/wxPython/src/helpers.h index 8ccf0d1987..9e0945d42f 100644 --- a/utils/wxPython/src/helpers.h +++ b/utils/wxPython/src/helpers.h @@ -16,11 +16,29 @@ #include +//---------------------------------------------------------------------- + +// if we want to handle threads and Python threads are available... +#if defined(WXP_USE_THREAD) && defined(WITH_THREAD) + +#define WXP_WITH_THREAD +#define wxPy_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS +#define wxPy_END_ALLOW_THREADS Py_END_ALLOW_THREADS + +#else // no Python threads... +#undef WXP_WITH_THREAD +#define wxPy_BEGIN_ALLOW_THREADS +#define wxPy_END_ALLOW_THREADS +#endif + + //---------------------------------------------------------------------- class wxPyApp: public wxApp { public: + wxPyApp(); + ~wxPyApp(); int MainLoop(void); bool OnInit(void); void AfterMainLoop(void); @@ -66,8 +84,8 @@ extern wxString wxPyEmptyStr; class wxPyCallback : public wxObject { public: - wxPyCallback(PyObject* func) { m_func = func; Py_INCREF(m_func); } - ~wxPyCallback() { Py_DECREF(m_func); } + wxPyCallback(PyObject* func); + ~wxPyCallback(); void EventThunker(wxEvent& event); @@ -100,11 +118,38 @@ private: PyObject* func; }; +//--------------------------------------------------------------------------- + +class wxPyEvent : public wxCommandEvent { + DECLARE_DYNAMIC_CLASS(wxPyEvent) +public: + wxPyEvent(wxEventType commandType = wxEVT_NULL, PyObject* userData = Py_None); + ~wxPyEvent(); + + void SetUserData(PyObject* userData); + PyObject* GetUserData(); + +private: + PyObject* m_userData; +}; + //--------------------------------------------------------------------------- ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.7 1999/04/30 03:29:18 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.6.4.1 1999/03/27 23:29:14 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// // Revision 1.6 1998/11/25 08:45:26 RD +// // Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon // Added events for wxGrid // Other various fixes and additions diff --git a/utils/wxPython/src/image.i b/utils/wxPython/src/image.i new file mode 100644 index 0000000000..0674cb8e22 --- /dev/null +++ b/utils/wxPython/src/image.i @@ -0,0 +1,152 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: image.i +// Purpose: SWIG interface file for wxImage, wxImageHandler, etc. +// +// Author: Robin Dunn +// +// Created: 28-Apr-1999 +// RCS-ID: $Id$ +// Copyright: (c) 1998 by Total Control Software +// Licence: wxWindows license +///////////////////////////////////////////////////////////////////////////// + + +%module image + +%{ +#include "helpers.h" +#include +%} + +//---------------------------------------------------------------------- + +%include typemaps.i +%include my_typemaps.i + +// Import some definitions of other classes, etc. +%import _defs.i +%import misc.i +%import gdi.i + +//--------------------------------------------------------------------------- + +class wxImageHandler { +public: + wxImageHandler(); + wxString GetName(); + wxString GetExtension(); + long GetType(); + wxString GetMimeType(); + + //bool LoadFile(wxImage* image, wxInputStream& stream); + //bool SaveFile(wxImage* image, wxOutputStream& stream); + + void SetName(const wxString& name); + void SetExtension(const wxString& extension); + void SetType(long type); + void SetMimeType(const wxString& mimetype); +}; + +//--------------------------------------------------------------------------- + +class wxPNGHandler : public wxImageHandler { +public: + wxPNGHandler(); +}; + + +class wxJPEGHandler : public wxImageHandler { +public: + wxJPEGHandler(); +}; + + +class wxBMPHandler : public wxImageHandler { +public: + wxBMPHandler(); +}; + + +class wxGIFHandler : public wxImageHandler { +public: + wxGIFHandler(); +}; + + + +//--------------------------------------------------------------------------- + +class wxImage { +public: + wxImage( const wxString& name, long type = wxBITMAP_TYPE_PNG ); + ~wxImage(); + + wxBitmap ConvertToBitmap(); + void Create( int width, int height ); + void Destroy(); + wxImage Scale( int width, int height ); + + void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b ); + unsigned char GetRed( int x, int y ); + unsigned char GetGreen( int x, int y ); + unsigned char GetBlue( int x, int y ); + + bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_PNG ); + %name(LoadMimeFile)bool LoadFile( const wxString& name, const wxString& mimetype ); + + bool SaveFile( const wxString& name, int type ); + %name(SaveMimeFile)bool SaveFile( const wxString& name, const wxString& mimetype ); + + bool Ok(); + int GetWidth(); + int GetHeight(); + + unsigned char *GetData(); + void SetData( unsigned char *data ); + + void SetMaskColour( unsigned char r, unsigned char g, unsigned char b ); + unsigned char GetMaskRed(); + unsigned char GetMaskGreen(); + unsigned char GetMaskBlue(); + void SetMask( bool mask = TRUE ); + bool HasMask(); + +}; + +// Alternate constructors +%new wxImage* wxNullImage(); +%new wxImage* wxEmptyImage(int width, int height); +%new wxImage* wxImageFromMime(const wxString& name, const wxString& mimetype); +%new wxImage* wxImageFromBitmap(const wxBitmap &bitmap); +%{ + wxImage* wxNullImage() { + return new wxImage; + } + + wxImage* wxEmptyImage(int width, int height) { + return new wxImage(width, height); + } + + wxImage* wxImageFromMime(const wxString& name, const wxString& mimetype) { + return new wxImage(name, mimetype); + } + + wxImage* wxImageFromBitmap(const wxBitmap &bitmap) { + return new wxImage(bitmap); + } +%} + +// Static Methods +void wxImage_AddHandler(wxImageHandler *handler); +%{ + void wxImage_AddHandler(wxImageHandler *handler) { + wxImage::AddHandler(handler); + } +%} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + + + diff --git a/utils/wxPython/src/makefile.vc b/utils/wxPython/src/makefile.vc index a9c66110de..4692888290 100644 --- a/utils/wxPython/src/makefile.vc +++ b/utils/wxPython/src/makefile.vc @@ -9,7 +9,7 @@ # Copyright: (c) 1998 by Total Control Software # Licence: wxWindows license #---------------------------------------------------------------------------- -VERSION=2.0b6 +VERSION=2.0b9 # Set WXDIR to the root wxWindows directory for your system WXDIR = $(WXWIN) @@ -26,27 +26,49 @@ FINAL=0 TARGETDIR=.. # Set this to 1 for make to pre-compile the Python modules, 0 to -# just copy the sources and let Python compile them at the first -# runtime. +# just copy the sources and let Python compile them the first +# time they are imported. COMPILEPY=0 -# If your wxWindows is built as a DLL, set this to 1. Using 0 means -# that wxWindows will be staticaly linked with wxPython. -WXUSINGDLL=1 +# If your wxWindows is built as a DLL, set this to 1. Using 0 or unset +# means that wxWindows will be staticaly linked with wxPython. +#WXUSINGDLL=1 + +# If you want to compile in code to aquire/release the Python +# Interpreter Lock at the appropriate places +WXP_USE_THREAD=1 + + +# Set this if you want to build the wxGLCanvas +WITH_GLCANVAS=1 # (experimental) SEPARATE=0 #---------------------------------------------------------------------- +!if "$(WXP_USE_THREAD)" == "1" +THREAD=-DWXP_USE_THREAD=1 +!endif + +#---------------------------------------------------------------------- + NOPCH=1 THISDIR=$(WXDIR)\utils\wxPython -EXTRALIBS=$(PYTHONDIR)\libs\python15.lib -EXTRAINC=-I$(PYTHONDIR)\include -I. -EXTRAFLAGS=/Fpwxp.pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H -OVERRIDEFLAGS=/GX- /DwxUSE_GLOBAL_MEMORY_OPERATORS=0 $(OTHERCFLAGS) +EXTRALIBS=$(PYTHONDIR)\libs\python15.lib $(GLLIBS) +#EXTRALIBS=$(PYTHONDIR)\PCbuild\python15_d.lib -D_DEBUG +EXTRAINC=-I$(PYTHONDIR)\include -I. -I$(WXDIR)\utils\glcanvas\win +EXTRAFLAGS=/Fpwxp.pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H $(THREAD) +OVERRIDEFLAGS=/GX- $(OTHERCFLAGS) + + +!if "$(WITH_GLCANVAS)" == "1" +GLLIBS=$(WXDIR)\lib\glcanvas.lib glu32.lib opengl32.lib +OTHERSWIGFLAGS=-DWITH_GLCANVAS +OTHERCFLAGS=-DWITH_GLCANVAS +!endif SWIGFLAGS=-c++ -shadow -python -dnone -D__WXMSW__ $(OTHERSWIGFLAGS) GENCODEDIR=msw @@ -61,16 +83,23 @@ TARGET = wxc OBJECTS = wx.obj helpers.obj windows.obj events.obj \ misc.obj gdi.obj mdi.obj controls.obj \ controls2.obj windows2.obj cmndlgs.obj stattool.obj \ - frames.obj windows3.obj \ + frames.obj windows3.obj image.obj \ !if "$(SEPARATE)" == "0" - utils.obj + utils.obj \ +!if "$(WITH_GLCANVAS)" == "1" + glcanvas.obj +!endif !else -OTHERCFLAGS=-DSEPARATE=1 -OTHERSWIGFLAGS=-DSEPARATE +OTHERCFLAGS=$(OTHERCFLAGS) -DSEPARATE=1 +OTHERSWIGFLAGS=$(OTHERSWIGFLAGS) -DSEPARATE TARGET2 = utilsc OBJECTS2 = utils.obj target2=$(TARGETDIR)\$(TARGET2).pyd + +TARGET3 = glcanvasc +OBJECTS3 = glcanvas.obj +target3=$(TARGETDIR)\$(TARGET3).pyd !endif PYMODULES = $(TARGETDIR)\wx.py $(TARGETDIR)\events.py \ @@ -79,9 +108,11 @@ PYMODULES = $(TARGETDIR)\wx.py $(TARGETDIR)\events.py \ $(TARGETDIR)\controls.py $(TARGETDIR)\controls2.py \ $(TARGETDIR)\windows2.py $(TARGETDIR)\cmndlgs.py \ $(TARGETDIR)\stattool.py $(TARGETDIR)\frames.py \ - $(TARGETDIR)\utils.py $(TARGETDIR)\windows3.py \ - $(TARGETDIR)\__init__.py - + $(TARGETDIR)\windows3.py $(TARGETDIR)\__init__.py \ + $(TARGETDIR)\utils.py $(TARGETDIR)\image.py \ +!if "$(WITH_GLCANVAS)" == "1" + $(TARGETDIR)\glcanvas.py +!endif #---------------------------------------------------------------------- @@ -91,17 +122,13 @@ DEBUGLFLAGS = /DEBUG /INCREMENTAL:YES DEBUGLFLAGS = /INCREMENTAL:NO !endif -LFLAGS= $(DEBUGLFLAGS) /DLL /def:$(TARGET).def /subsystem:windows,3.50 \ - /machine:I386 /implib:./$(TARGET).lib /nologo - -LFLAGS2=$(DEBUGLFLAGS) /DLL /def:$(TARGET2).def /subsystem:windows,3.50 \ - /machine:I386 /implib:./$(TARGET2).lib /nologo +LFLAGS= $(DEBUGLFLAGS) /DLL /subsystem:windows,3.50 /machine:I386 /nologo #---------------------------------------------------------------------- -default: $(TARGETDIR)\$(TARGET).pyd $(target2) pycfiles +default: $(TARGETDIR)\$(TARGET).pyd $(target2) $(target3) pycfiles -all: wx $(TARGET) $(TARGET2) +all: wx $(TARGET) $(TARGET2) $(TARGET3) wx: cd $(WXDIR)\src\msw @@ -125,7 +152,7 @@ pycfiles : $(PYMODULES) $(TARGETDIR)\$(TARGET).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(TARGET).res $(link) @<< /out:$@ /dll -$(LFLAGS) +$(LFLAGS) /def:$(TARGET).def /implib:./$(TARGET).lib $(DUMMYOBJ) $(OBJECTS) $(TARGET).res $(LIBS) << @@ -133,9 +160,17 @@ $(LIBS) $(TARGETDIR)\$(TARGET2).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS2) $(link) @<< /out:$@ /dll -$(LFLAGS2) +$(LFLAGS) /def:$(TARGET2).def /implib:./$(TARGET2).lib $(DUMMYOBJ) $(OBJECTS2) -$(LIBS) +$(LIBS) wxc.lib +<< + +$(TARGETDIR)\$(TARGET3).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS3) + $(link) @<< +/out:$@ /dll +$(LFLAGS) /def:$(TARGET3).def /implib:./$(TARGET3).lib +$(DUMMYOBJ) $(OBJECTS3) +$(LIBS) $(WXDIR)\lib\glcanvas.lib glu32.lib opengl32.lib wxc.lib << @@ -171,6 +206,9 @@ clean: -erase $(TARGET2).exp -erase $(TARGET2).lib -erase $(TARGETDIR)\$(TARGET2).* + -erase $(TARGET3).exp + -erase $(TARGET3).lib + -erase $(TARGETDIR)\$(TARGET3).* !endif -erase $(TARGETDIR)\$(TARGET).pyd -erase $(TARGETDIR)\*.py @@ -224,12 +262,21 @@ $(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i my_typemap $(GENCODEDIR)/cmndlgs.cpp $(GENCODEDIR)/cmndlgs.py : cmndlgs.i my_typemaps.i _defs.i $(GENCODEDIR)/stattool.cpp $(GENCODEDIR)/stattool.py : stattool.i my_typemaps.i _defs.i $(GENCODEDIR)/frames.cpp $(GENCODEDIR)/frames.py : frames.i my_typemaps.i _defs.i +$(GENCODEDIR)/image.cpp $(GENCODEDIR)/image.py : image.i my_typemaps.i _defs.i !if "$(SEPARATE)" == "1" $(GENCODEDIR)\utils.cpp $(GENCODEDIR)\utils.py : utils.i my_typemaps.i swig $(SWIGFLAGS) -o $(GENCODEDIR)/utils.cpp utils.i + +!if "$(WITH_GLCANVAS)" == "1" +$(GENCODEDIR)\glcanvas.cpp $(GENCODEDIR)\glcanvas.py : glcanvas.i my_typemaps.i + swig $(SWIGFLAGS) -c -o $(GENCODEDIR)/glcanvas.cpp glcanvas.i +!endif !else $(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py : utils.i my_typemaps.i _defs.i +!if "$(WITH_GLCANVAS)" == "1" +$(GENCODEDIR)/glcanvas.cpp $(GENCODEDIR)/glcanvas.py : glcanvas.i my_typemaps.i _defs.i +!endif !endif @@ -246,8 +293,12 @@ $(TARGETDIR)\controls2.py : $(GENCODEDIR)\controls2.py $(TARGETDIR)\cmndlgs.py : $(GENCODEDIR)\cmndlgs.py $(TARGETDIR)\frames.py : $(GENCODEDIR)\frames.py $(TARGETDIR)\stattool.py : $(GENCODEDIR)\stattool.py -$(TARGETDIR)\utils.py : $(GENCODEDIR)\utils.py $(TARGETDIR)\__init__.py : __init__.py +$(TARGETDIR)\utils.py : $(GENCODEDIR)\utils.py +$(TARGETDIR)\image.py : $(GENCODEDIR)\utils.py +!if "$(WITH_GLCANVAS)" == "1" +$(TARGETDIR)\glcanvas.py : $(GENCODEDIR)\glcanvas.py +!endif SOURCES = $(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py \ @@ -264,6 +315,10 @@ SOURCES = $(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py \ $(GENCODEDIR)/stattool.cpp $(GENCODEDIR)/stattool.py \ $(GENCODEDIR)/frames.cpp $(GENCODEDIR)/frames.py \ $(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py \ + $(GENCODEDIR)/image.cpp $(GENCODEDIR)/image.py \ +!if "$(WITH_GLCANVAS)" == "1" + $(GENCODEDIR)/glcanvas.cpp $(GENCODEDIR)/glcanvas.py \ +!endif sources : $(SOURCES) @@ -275,86 +330,3 @@ dist: #------------------------------------------------------------------------ # -# $Log$ -# Revision 1.4 1999/03/05 07:22:30 RD -# Minor wxPython changes for wxWin 2.0 -# -# Revision 1.3 1999/02/25 07:08:33 RD -# -# wxPython version 2.0b5 -# -# Revision 1.2 1999/02/20 09:03:00 RD -# Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a -# window handle. If you can get the window handle into the python code, -# it should just work... More news on this later. -# -# Added wxImageList, wxToolTip. -# -# Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the -# wxRegConfig class. -# -# As usual, some bug fixes, tweaks, etc. -# -# Revision 1.1 1999/02/06 23:47:03 RD -# -# Changing makefile.nt to makefile.vc as in rest of wxWindows -# -# Revision 1.10 1999/02/01 00:10:40 RD -# -# Added the missing EVT_LIST_ITEM_SELECTED and friends. -# -# Revision 1.9 1999/01/30 07:30:13 RD -# -# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc. -# -# Various cleanup, tweaks, minor additions, etc. to maintain -# compatibility with the current wxWindows. -# -# Revision 1.8 1998/12/21 19:58:06 RD -# -# Now compiles with /GX- on MSW. -# -# Revision 1.7 1998/12/15 20:41:20 RD -# Changed the import semantics from "from wxPython import *" to "from -# wxPython.wx import *" This is for people who are worried about -# namespace pollution, they can use "from wxPython import wx" and then -# prefix all the wxPython identifiers with "wx." -# -# Added wxTaskbarIcon for wxMSW. -# -# Made the events work for wxGrid. -# -# Added wxConfig. -# -# Added wxMiniFrame for wxGTK, (untested.) -# -# Changed many of the args and return values that were pointers to gdi -# objects to references to reflect changes in the wxWindows API. -# -# Other assorted fixes and additions. -# -# Revision 1.6 1998/10/02 06:40:41 RD -# -# Version 0.4 of wxPython for MSW. -# -# Revision 1.5 1998/08/19 00:38:23 RD -# -# A few tweaks -# -# Revision 1.4 1998/08/18 21:55:10 RD -# -# New build directory structure -# -# Revision 1.3 1998/08/15 07:36:37 RD -# - Moved the header in the .i files out of the code that gets put into -# the .cpp files. It caused CVS conflicts because of the RCS ID being -# different each time. -# -# - A few minor fixes. -# -# Revision 1.2 1998/08/14 03:34:23 RD -# made pre-compiling the python files optional -# -# Revision 1.1 1998/08/09 08:25:51 RD -# Initial version -# diff --git a/utils/wxPython/src/misc.i b/utils/wxPython/src/misc.i index 3f411f7dba..984a802bd8 100644 --- a/utils/wxPython/src/misc.i +++ b/utils/wxPython/src/misc.i @@ -193,8 +193,11 @@ void wxSetCursor(wxCursor& cursor); //--------------------------------------------------------------------------- // Miscellaneous functions -long NewId(); -void RegisterId(long id); +long wxNewId(); +void wxRegisterId(long id); +%name(NewId) long wxNewId(); +%name(RegisterId) void wxRegisterId(long id); + void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR); void wxBell(); void wxDisplaySize(int *OUTPUT, int *OUTPUT); @@ -217,6 +220,7 @@ int wxGetOsVersion(int *OUTPUT, int *OUTPUT); #endif bool wxYield(); +bool wxSafeYield(); %inline %{ char* wxGetResource(char *section, char *entry, char *file = NULL) { @@ -407,7 +411,19 @@ public: ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.14 1999/04/30 03:29:19 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.13.4.1 1999/03/27 23:29:15 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// // Revision 1.13 1999/02/25 07:08:34 RD +// // wxPython version 2.0b5 // // Revision 1.12 1999/02/20 10:02:37 RD diff --git a/utils/wxPython/src/msw/cmndlgs.cpp b/utils/wxPython/src/msw/cmndlgs.cpp index 8cd6e9a23f..909af27153 100644 --- a/utils/wxPython/src/msw/cmndlgs.cpp +++ b/utils/wxPython/src/msw/cmndlgs.cpp @@ -126,8 +126,12 @@ static PyObject *_wrap_new_wxColourData(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxColourData")) return NULL; - _result = (wxColourData *)new_wxColourData(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColourData_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxColourData *)new_wxColourData(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColourData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -147,8 +151,12 @@ static PyObject *_wrap_delete_wxColourData(PyObject *self, PyObject *args) { return NULL; } } - delete_wxColourData(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxColourData(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -169,8 +177,12 @@ static PyObject *_wrap_wxColourData_GetChooseFull(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxColourData_GetChooseFull(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxColourData_GetChooseFull(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -191,9 +203,13 @@ static PyObject *_wrap_wxColourData_GetColour(PyObject *self, PyObject *args) { return NULL; } } - wxColour & _result_ref = wxColourData_GetColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxColourData_GetColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -216,8 +232,12 @@ static PyObject *_wrap_wxColourData_GetCustomColour(PyObject *self, PyObject *ar return NULL; } } - _result = new wxColour (wxColourData_GetCustomColour(_arg0,_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxColour (wxColourData_GetCustomColour(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -238,8 +258,12 @@ static PyObject *_wrap_wxColourData_SetChooseFull(PyObject *self, PyObject *args return NULL; } } - wxColourData_SetChooseFull(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColourData_SetChooseFull(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -267,8 +291,12 @@ static PyObject *_wrap_wxColourData_SetColour(PyObject *self, PyObject *args) { return NULL; } } - wxColourData_SetColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColourData_SetColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -297,8 +325,12 @@ static PyObject *_wrap_wxColourData_SetCustomColour(PyObject *self, PyObject *ar return NULL; } } - wxColourData_SetCustomColour(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColourData_SetCustomColour(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -360,8 +392,12 @@ static PyObject *_wrap_new_wxColourDialog(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxColourDialog *)new_wxColourDialog(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColourDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxColourDialog *)new_wxColourDialog(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColourDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -383,9 +419,13 @@ static PyObject *_wrap_wxColourDialog_GetColourData(PyObject *self, PyObject *ar return NULL; } } - wxColourData & _result_ref = wxColourDialog_GetColourData(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColourData & _result_ref = wxColourDialog_GetColourData(_arg0); _result = (wxColourData *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColourData_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColourData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -406,8 +446,12 @@ static PyObject *_wrap_wxColourDialog_ShowModal(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxColourDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxColourDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -471,8 +515,12 @@ static PyObject *_wrap_new_wxDirDialog(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxDirDialog *)new_wxDirDialog(_arg0,_arg1,_arg2,_arg3,*_arg4); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxDirDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxDirDialog *)new_wxDirDialog(_arg0,_arg1,_arg2,_arg3,*_arg4); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxDirDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -493,8 +541,12 @@ static PyObject *_wrap_wxDirDialog_GetPath(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxDirDialog_GetPath(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxDirDialog_GetPath(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -519,8 +571,12 @@ static PyObject *_wrap_wxDirDialog_GetMessage(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxDirDialog_GetMessage(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxDirDialog_GetMessage(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -545,8 +601,12 @@ static PyObject *_wrap_wxDirDialog_GetStyle(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDirDialog_GetStyle(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDirDialog_GetStyle(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -572,10 +632,14 @@ static PyObject *_wrap_wxDirDialog_SetMessage(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxDirDialog_SetMessage(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDirDialog_SetMessage(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -606,10 +670,14 @@ static PyObject *_wrap_wxDirDialog_SetPath(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxDirDialog_SetPath(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDirDialog_SetPath(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -634,8 +702,12 @@ static PyObject *_wrap_wxDirDialog_ShowModal(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxDirDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxDirDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -701,8 +773,12 @@ static PyObject *_wrap_new_wxFileDialog(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxFileDialog *)new_wxFileDialog(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,*_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFileDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxFileDialog *)new_wxFileDialog(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,*_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFileDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -723,8 +799,12 @@ static PyObject *_wrap_wxFileDialog_GetDirectory(PyObject *self, PyObject *args) return NULL; } } - _result = new wxString (wxFileDialog_GetDirectory(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFileDialog_GetDirectory(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -749,8 +829,12 @@ static PyObject *_wrap_wxFileDialog_GetFilename(PyObject *self, PyObject *args) return NULL; } } - _result = new wxString (wxFileDialog_GetFilename(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFileDialog_GetFilename(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -775,8 +859,12 @@ static PyObject *_wrap_wxFileDialog_GetFilterIndex(PyObject *self, PyObject *arg return NULL; } } - _result = (int )wxFileDialog_GetFilterIndex(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFileDialog_GetFilterIndex(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -796,8 +884,12 @@ static PyObject *_wrap_wxFileDialog_GetMessage(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxFileDialog_GetMessage(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFileDialog_GetMessage(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -822,8 +914,12 @@ static PyObject *_wrap_wxFileDialog_GetPath(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxFileDialog_GetPath(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFileDialog_GetPath(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -848,8 +944,12 @@ static PyObject *_wrap_wxFileDialog_GetStyle(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxFileDialog_GetStyle(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxFileDialog_GetStyle(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -869,8 +969,12 @@ static PyObject *_wrap_wxFileDialog_GetWildcard(PyObject *self, PyObject *args) return NULL; } } - _result = new wxString (wxFileDialog_GetWildcard(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFileDialog_GetWildcard(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -901,10 +1005,14 @@ static PyObject *_wrap_wxFileDialog_SetDirectory(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFileDialog_SetDirectory(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFileDialog_SetDirectory(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -935,10 +1043,14 @@ static PyObject *_wrap_wxFileDialog_SetFilename(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFileDialog_SetFilename(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFileDialog_SetFilename(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -963,8 +1075,12 @@ static PyObject *_wrap_wxFileDialog_SetFilterIndex(PyObject *self, PyObject *arg return NULL; } } - wxFileDialog_SetFilterIndex(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFileDialog_SetFilterIndex(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -991,10 +1107,14 @@ static PyObject *_wrap_wxFileDialog_SetMessage(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFileDialog_SetMessage(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFileDialog_SetMessage(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1025,10 +1145,14 @@ static PyObject *_wrap_wxFileDialog_SetPath(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFileDialog_SetPath(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFileDialog_SetPath(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1053,8 +1177,12 @@ static PyObject *_wrap_wxFileDialog_SetStyle(PyObject *self, PyObject *args) { return NULL; } } - wxFileDialog_SetStyle(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFileDialog_SetStyle(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1081,10 +1209,14 @@ static PyObject *_wrap_wxFileDialog_SetWildcard(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFileDialog_SetWildcard(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFileDialog_SetWildcard(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1109,8 +1241,12 @@ static PyObject *_wrap_wxFileDialog_ShowModal(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxFileDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFileDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1182,14 +1318,14 @@ static PyObject *_wrap_new_wxSingleChoiceDialog(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } { if (!PyString_Check(_obj2)) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_obj4) { @@ -1205,10 +1341,19 @@ static PyObject *_wrap_new_wxSingleChoiceDialog(PyObject *self, PyObject *args) } } { - _arg3 = PyList_Size(_obj4); + if (_obj4) { + _arg3 = PyList_Size(_obj4); + } + else { + _arg3 = 0; + } } - _result = (wxSingleChoiceDialog *)new_wxSingleChoiceDialog(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxSingleChoiceDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSingleChoiceDialog *)new_wxSingleChoiceDialog(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxSingleChoiceDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj1) @@ -1240,8 +1385,12 @@ static PyObject *_wrap_wxSingleChoiceDialog_GetSelection(PyObject *self, PyObjec return NULL; } } - _result = (int )wxSingleChoiceDialog_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSingleChoiceDialog_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1261,8 +1410,12 @@ static PyObject *_wrap_wxSingleChoiceDialog_GetStringSelection(PyObject *self, P return NULL; } } - _result = new wxString (wxSingleChoiceDialog_GetStringSelection(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxSingleChoiceDialog_GetStringSelection(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1287,8 +1440,12 @@ static PyObject *_wrap_wxSingleChoiceDialog_SetSelection(PyObject *self, PyObjec return NULL; } } - wxSingleChoiceDialog_SetSelection(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSingleChoiceDialog_SetSelection(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1309,8 +1466,12 @@ static PyObject *_wrap_wxSingleChoiceDialog_ShowModal(PyObject *self, PyObject * return NULL; } } - _result = (int )wxSingleChoiceDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSingleChoiceDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1375,8 +1536,12 @@ static PyObject *_wrap_new_wxTextEntryDialog(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxTextEntryDialog *)new_wxTextEntryDialog(_arg0,_arg1,_arg2,_arg3,_arg4,*_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextEntryDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTextEntryDialog *)new_wxTextEntryDialog(_arg0,_arg1,_arg2,_arg3,_arg4,*_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextEntryDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1397,8 +1562,12 @@ static PyObject *_wrap_wxTextEntryDialog_GetValue(PyObject *self, PyObject *args return NULL; } } - _result = new wxString (wxTextEntryDialog_GetValue(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxTextEntryDialog_GetValue(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1429,10 +1598,14 @@ static PyObject *_wrap_wxTextEntryDialog_SetValue(PyObject *self, PyObject *args PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxTextEntryDialog_SetValue(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTextEntryDialog_SetValue(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1457,8 +1630,12 @@ static PyObject *_wrap_wxTextEntryDialog_ShowModal(PyObject *self, PyObject *arg return NULL; } } - _result = (int )wxTextEntryDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxTextEntryDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1471,8 +1648,12 @@ static PyObject *_wrap_new_wxFontData(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxFontData")) return NULL; - _result = (wxFontData *)new_wxFontData(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFontData_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxFontData *)new_wxFontData(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFontData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1492,8 +1673,12 @@ static PyObject *_wrap_delete_wxFontData(PyObject *self, PyObject *args) { return NULL; } } - delete_wxFontData(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxFontData(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1516,8 +1701,12 @@ static PyObject *_wrap_wxFontData_EnableEffects(PyObject *self, PyObject *args) } } _arg1 = (bool ) tempbool1; - wxFontData_EnableEffects(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData_EnableEffects(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1538,8 +1727,12 @@ static PyObject *_wrap_wxFontData_GetAllowSymbols(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxFontData_GetAllowSymbols(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxFontData_GetAllowSymbols(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1560,9 +1753,13 @@ static PyObject *_wrap_wxFontData_GetColour(PyObject *self, PyObject *args) { return NULL; } } - wxColour & _result_ref = wxFontData_GetColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxFontData_GetColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1584,8 +1781,12 @@ static PyObject *_wrap_wxFontData_GetChosenFont(PyObject *self, PyObject *args) return NULL; } } - _result = new wxFont (wxFontData_GetChosenFont(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxFont (wxFontData_GetChosenFont(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1606,8 +1807,12 @@ static PyObject *_wrap_wxFontData_GetEnableEffects(PyObject *self, PyObject *arg return NULL; } } - _result = (bool )wxFontData_GetEnableEffects(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxFontData_GetEnableEffects(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1628,8 +1833,12 @@ static PyObject *_wrap_wxFontData_GetInitialFont(PyObject *self, PyObject *args) return NULL; } } - _result = new wxFont (wxFontData_GetInitialFont(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxFont (wxFontData_GetInitialFont(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1650,8 +1859,12 @@ static PyObject *_wrap_wxFontData_GetShowHelp(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxFontData_GetShowHelp(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxFontData_GetShowHelp(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1673,8 +1886,12 @@ static PyObject *_wrap_wxFontData_SetAllowSymbols(PyObject *self, PyObject *args } } _arg1 = (bool ) tempbool1; - wxFontData_SetAllowSymbols(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData_SetAllowSymbols(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1702,8 +1919,12 @@ static PyObject *_wrap_wxFontData_SetChosenFont(PyObject *self, PyObject *args) return NULL; } } - wxFontData_SetChosenFont(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData_SetChosenFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1731,8 +1952,12 @@ static PyObject *_wrap_wxFontData_SetColour(PyObject *self, PyObject *args) { return NULL; } } - wxFontData_SetColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData_SetColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1760,8 +1985,12 @@ static PyObject *_wrap_wxFontData_SetInitialFont(PyObject *self, PyObject *args) return NULL; } } - wxFontData_SetInitialFont(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData_SetInitialFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1783,8 +2012,12 @@ static PyObject *_wrap_wxFontData_SetRange(PyObject *self, PyObject *args) { return NULL; } } - wxFontData_SetRange(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData_SetRange(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1807,8 +2040,12 @@ static PyObject *_wrap_wxFontData_SetShowHelp(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxFontData_SetShowHelp(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData_SetShowHelp(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1870,8 +2107,12 @@ static PyObject *_wrap_new_wxFontDialog(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxFontDialog *)new_wxFontDialog(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFontDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxFontDialog *)new_wxFontDialog(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFontDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1893,9 +2134,13 @@ static PyObject *_wrap_wxFontDialog_GetFontData(PyObject *self, PyObject *args) return NULL; } } - wxFontData & _result_ref = wxFontDialog_GetFontData(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFontData & _result_ref = wxFontDialog_GetFontData(_arg0); _result = (wxFontData *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFontData_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFontData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1916,661 +2161,845 @@ static PyObject *_wrap_wxFontDialog_ShowModal(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxFontDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFontDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define new_wxPageSetupData() (new wxPageSetupData()) -static PyObject *_wrap_new_wxPageSetupData(PyObject *self, PyObject *args) { +#define new_wxPageSetupDialogData() (new wxPageSetupDialogData()) +static PyObject *_wrap_new_wxPageSetupDialogData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _result; + wxPageSetupDialogData * _result; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,":new_wxPageSetupData")) + if(!PyArg_ParseTuple(args,":new_wxPageSetupDialogData")) return NULL; - _result = (wxPageSetupData *)new_wxPageSetupData(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPageSetupData_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPageSetupDialogData *)new_wxPageSetupDialogData(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPageSetupDialogData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define delete_wxPageSetupData(_swigobj) (delete _swigobj) -static PyObject *_wrap_delete_wxPageSetupData(PyObject *self, PyObject *args) { +#define delete_wxPageSetupDialogData(_swigobj) (delete _swigobj) +static PyObject *_wrap_delete_wxPageSetupDialogData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:delete_wxPageSetupData",&_argc0)) + if(!PyArg_ParseTuple(args,"s:delete_wxPageSetupDialogData",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxPageSetupData. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxPageSetupDialogData. Expected _wxPageSetupDialogData_p."); return NULL; } } - delete_wxPageSetupData(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxPageSetupDialogData(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_EnableHelp(_swigobj,_swigarg0) (_swigobj->EnableHelp(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_EnableHelp(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_EnableHelp(_swigobj,_swigarg0) (_swigobj->EnableHelp(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_EnableHelp(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_EnableHelp",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPageSetupDialogData_EnableHelp",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_EnableHelp. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_EnableHelp. Expected _wxPageSetupDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPageSetupData_EnableHelp(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_EnableHelp(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_EnableMargins(_swigobj,_swigarg0) (_swigobj->EnableMargins(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_EnableMargins(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_EnableMargins(_swigobj,_swigarg0) (_swigobj->EnableMargins(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_EnableMargins(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_EnableMargins",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPageSetupDialogData_EnableMargins",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_EnableMargins. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_EnableMargins. Expected _wxPageSetupDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPageSetupData_EnableMargins(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_EnableMargins(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_EnableOrientation(_swigobj,_swigarg0) (_swigobj->EnableOrientation(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_EnableOrientation(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_EnableOrientation(_swigobj,_swigarg0) (_swigobj->EnableOrientation(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_EnableOrientation(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_EnableOrientation",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPageSetupDialogData_EnableOrientation",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_EnableOrientation. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_EnableOrientation. Expected _wxPageSetupDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPageSetupData_EnableOrientation(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_EnableOrientation(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_EnablePaper(_swigobj,_swigarg0) (_swigobj->EnablePaper(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_EnablePaper(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_EnablePaper(_swigobj,_swigarg0) (_swigobj->EnablePaper(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_EnablePaper(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_EnablePaper",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPageSetupDialogData_EnablePaper",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_EnablePaper. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_EnablePaper. Expected _wxPageSetupDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPageSetupData_EnablePaper(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_EnablePaper(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_EnablePrinter(_swigobj,_swigarg0) (_swigobj->EnablePrinter(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_EnablePrinter(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_EnablePrinter(_swigobj,_swigarg0) (_swigobj->EnablePrinter(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_EnablePrinter(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_EnablePrinter",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPageSetupDialogData_EnablePrinter",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_EnablePrinter. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_EnablePrinter. Expected _wxPageSetupDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPageSetupData_EnablePrinter(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_EnablePrinter(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_GetPaperSize(_swigobj) (_swigobj->GetPaperSize()) -static PyObject *_wrap_wxPageSetupData_GetPaperSize(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_GetDefaultMinMargins(_swigobj) (_swigobj->GetDefaultMinMargins()) +static PyObject *_wrap_wxPageSetupDialogData_GetDefaultMinMargins(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetDefaultMinMargins",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetDefaultMinMargins. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPageSetupDialogData_GetDefaultMinMargins(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetEnableMargins(_swigobj) (_swigobj->GetEnableMargins()) +static PyObject *_wrap_wxPageSetupDialogData_GetEnableMargins(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetEnableMargins",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetEnableMargins. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPageSetupDialogData_GetEnableMargins(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetEnableOrientation(_swigobj) (_swigobj->GetEnableOrientation()) +static PyObject *_wrap_wxPageSetupDialogData_GetEnableOrientation(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetEnableOrientation",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetEnableOrientation. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPageSetupDialogData_GetEnableOrientation(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetEnablePaper(_swigobj) (_swigobj->GetEnablePaper()) +static PyObject *_wrap_wxPageSetupDialogData_GetEnablePaper(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetEnablePaper",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetEnablePaper. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPageSetupDialogData_GetEnablePaper(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetEnablePrinter(_swigobj) (_swigobj->GetEnablePrinter()) +static PyObject *_wrap_wxPageSetupDialogData_GetEnablePrinter(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetEnablePrinter",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetEnablePrinter. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPageSetupDialogData_GetEnablePrinter(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetEnableHelp(_swigobj) (_swigobj->GetEnableHelp()) +static PyObject *_wrap_wxPageSetupDialogData_GetEnableHelp(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetEnableHelp",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetEnableHelp. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPageSetupDialogData_GetEnableHelp(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetDefaultInfo(_swigobj) (_swigobj->GetDefaultInfo()) +static PyObject *_wrap_wxPageSetupDialogData_GetDefaultInfo(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetDefaultInfo",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetDefaultInfo. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPageSetupDialogData_GetDefaultInfo(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetMarginTopLeft(_swigobj) (_swigobj->GetMarginTopLeft()) +static PyObject *_wrap_wxPageSetupDialogData_GetMarginTopLeft(PyObject *self, PyObject *args) { PyObject * _resultobj; wxPoint * _result; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; char * _argc0 = 0; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetPaperSize",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetMarginTopLeft",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetPaperSize. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetMarginTopLeft. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = new wxPoint (wxPageSetupData_GetPaperSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxPageSetupDialogData_GetMarginTopLeft(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define wxPageSetupData_GetMarginTopLeft(_swigobj) (_swigobj->GetMarginTopLeft()) -static PyObject *_wrap_wxPageSetupData_GetMarginTopLeft(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_GetMarginBottomRight(_swigobj) (_swigobj->GetMarginBottomRight()) +static PyObject *_wrap_wxPageSetupDialogData_GetMarginBottomRight(PyObject *self, PyObject *args) { PyObject * _resultobj; wxPoint * _result; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; char * _argc0 = 0; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetMarginTopLeft",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetMarginBottomRight",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetMarginTopLeft. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetMarginBottomRight. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = new wxPoint (wxPageSetupData_GetMarginTopLeft(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxPageSetupDialogData_GetMarginBottomRight(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define wxPageSetupData_GetMarginBottomRight(_swigobj) (_swigobj->GetMarginBottomRight()) -static PyObject *_wrap_wxPageSetupData_GetMarginBottomRight(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_GetMinMarginTopLeft(_swigobj) (_swigobj->GetMinMarginTopLeft()) +static PyObject *_wrap_wxPageSetupDialogData_GetMinMarginTopLeft(PyObject *self, PyObject *args) { PyObject * _resultobj; wxPoint * _result; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; char * _argc0 = 0; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetMarginBottomRight",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetMinMarginTopLeft",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetMarginBottomRight. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetMinMarginTopLeft. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = new wxPoint (wxPageSetupData_GetMarginBottomRight(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxPageSetupDialogData_GetMinMarginTopLeft(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define wxPageSetupData_GetMinMarginTopLeft(_swigobj) (_swigobj->GetMinMarginTopLeft()) -static PyObject *_wrap_wxPageSetupData_GetMinMarginTopLeft(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_GetMinMarginBottomRight(_swigobj) (_swigobj->GetMinMarginBottomRight()) +static PyObject *_wrap_wxPageSetupDialogData_GetMinMarginBottomRight(PyObject *self, PyObject *args) { PyObject * _resultobj; wxPoint * _result; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; char * _argc0 = 0; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetMinMarginTopLeft",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetMinMarginBottomRight",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetMinMarginTopLeft. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetMinMarginBottomRight. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = new wxPoint (wxPageSetupData_GetMinMarginTopLeft(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxPageSetupDialogData_GetMinMarginBottomRight(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define wxPageSetupData_GetMinMarginBottomRight(_swigobj) (_swigobj->GetMinMarginBottomRight()) -static PyObject *_wrap_wxPageSetupData_GetMinMarginBottomRight(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_GetPaperId(_swigobj) (_swigobj->GetPaperId()) +static PyObject *_wrap_wxPageSetupDialogData_GetPaperId(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPoint * _result; - wxPageSetupData * _arg0; + wxPaperSize _result; + wxPageSetupDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetPaperId",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetPaperId. Expected _wxPageSetupDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPaperSize )wxPageSetupDialogData_GetPaperId(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPageSetupDialogData_GetPaperSize(_swigobj) (_swigobj->GetPaperSize()) +static PyObject *_wrap_wxPageSetupDialogData_GetPaperSize(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxSize * _result; + wxPageSetupDialogData * _arg0; char * _argc0 = 0; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetMinMarginBottomRight",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetPaperSize",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetMinMarginBottomRight. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetPaperSize. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = new wxPoint (wxPageSetupData_GetMinMarginBottomRight(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxPageSetupDialogData_GetPaperSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define wxPageSetupData_GetOrientation(_swigobj) (_swigobj->GetOrientation()) -static PyObject *_wrap_wxPageSetupData_GetOrientation(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_GetPrintData(_swigobj) (_swigobj->GetPrintData()) +static PyObject *_wrap_wxPageSetupDialogData_GetPrintData(PyObject *self, PyObject *args) { PyObject * _resultobj; - int _result; - wxPageSetupData * _arg0; + wxPrintData * _result; + wxPageSetupDialogData * _arg0; char * _argc0 = 0; + char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetOrientation",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPageSetupDialogData_GetPrintData",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetOrientation. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_GetPrintData. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = (int )wxPageSetupData_GetOrientation(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintData & _result_ref = wxPageSetupDialogData_GetPrintData(_arg0); + _result = (wxPrintData *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintData_p"); + _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define wxPageSetupData_GetDefaultMinMargins(_swigobj) (_swigobj->GetDefaultMinMargins()) -static PyObject *_wrap_wxPageSetupData_GetDefaultMinMargins(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetDefaultInfo(_swigobj,_swigarg0) (_swigobj->SetDefaultInfo(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetDefaultInfo(PyObject *self, PyObject *args) { PyObject * _resultobj; - bool _result; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; + bool _arg1; char * _argc0 = 0; + int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetDefaultMinMargins",&_argc0)) + if(!PyArg_ParseTuple(args,"si:wxPageSetupDialogData_SetDefaultInfo",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetDefaultMinMargins. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetDefaultInfo. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = (bool )wxPageSetupData_GetDefaultMinMargins(_arg0); - _resultobj = Py_BuildValue("i",_result); + _arg1 = (bool ) tempbool1; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetDefaultInfo(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_GetEnableMargins(_swigobj) (_swigobj->GetEnableMargins()) -static PyObject *_wrap_wxPageSetupData_GetEnableMargins(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetDefaultMinMargins(_swigobj,_swigarg0) (_swigobj->SetDefaultMinMargins(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetDefaultMinMargins(PyObject *self, PyObject *args) { PyObject * _resultobj; - bool _result; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; + bool _arg1; char * _argc0 = 0; + int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetEnableMargins",&_argc0)) + if(!PyArg_ParseTuple(args,"si:wxPageSetupDialogData_SetDefaultMinMargins",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetEnableMargins. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetDefaultMinMargins. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = (bool )wxPageSetupData_GetEnableMargins(_arg0); - _resultobj = Py_BuildValue("i",_result); + _arg1 = (bool ) tempbool1; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetDefaultMinMargins(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_GetEnableOrientation(_swigobj) (_swigobj->GetEnableOrientation()) -static PyObject *_wrap_wxPageSetupData_GetEnableOrientation(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetMarginTopLeft(_swigobj,_swigarg0) (_swigobj->SetMarginTopLeft(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetMarginTopLeft(PyObject *self, PyObject *args) { PyObject * _resultobj; - bool _result; - wxPageSetupData * _arg0; - char * _argc0 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetEnableOrientation",&_argc0)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetEnableOrientation. Expected _wxPageSetupData_p."); - return NULL; - } - } - _result = (bool )wxPageSetupData_GetEnableOrientation(_arg0); - _resultobj = Py_BuildValue("i",_result); - return _resultobj; -} - -#define wxPageSetupData_GetEnablePaper(_swigobj) (_swigobj->GetEnablePaper()) -static PyObject *_wrap_wxPageSetupData_GetEnablePaper(PyObject *self, PyObject *args) { - PyObject * _resultobj; - bool _result; - wxPageSetupData * _arg0; - char * _argc0 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetEnablePaper",&_argc0)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetEnablePaper. Expected _wxPageSetupData_p."); - return NULL; - } - } - _result = (bool )wxPageSetupData_GetEnablePaper(_arg0); - _resultobj = Py_BuildValue("i",_result); - return _resultobj; -} - -#define wxPageSetupData_GetEnablePrinter(_swigobj) (_swigobj->GetEnablePrinter()) -static PyObject *_wrap_wxPageSetupData_GetEnablePrinter(PyObject *self, PyObject *args) { - PyObject * _resultobj; - bool _result; - wxPageSetupData * _arg0; - char * _argc0 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetEnablePrinter",&_argc0)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetEnablePrinter. Expected _wxPageSetupData_p."); - return NULL; - } - } - _result = (bool )wxPageSetupData_GetEnablePrinter(_arg0); - _resultobj = Py_BuildValue("i",_result); - return _resultobj; -} - -#define wxPageSetupData_GetEnableHelp(_swigobj) (_swigobj->GetEnableHelp()) -static PyObject *_wrap_wxPageSetupData_GetEnableHelp(PyObject *self, PyObject *args) { - PyObject * _resultobj; - bool _result; - wxPageSetupData * _arg0; - char * _argc0 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetEnableHelp",&_argc0)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetEnableHelp. Expected _wxPageSetupData_p."); - return NULL; - } - } - _result = (bool )wxPageSetupData_GetEnableHelp(_arg0); - _resultobj = Py_BuildValue("i",_result); - return _resultobj; -} - -#define wxPageSetupData_GetDefaultInfo(_swigobj) (_swigobj->GetDefaultInfo()) -static PyObject *_wrap_wxPageSetupData_GetDefaultInfo(PyObject *self, PyObject *args) { - PyObject * _resultobj; - bool _result; - wxPageSetupData * _arg0; - char * _argc0 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"s:wxPageSetupData_GetDefaultInfo",&_argc0)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_GetDefaultInfo. Expected _wxPageSetupData_p."); - return NULL; - } - } - _result = (bool )wxPageSetupData_GetDefaultInfo(_arg0); - _resultobj = Py_BuildValue("i",_result); - return _resultobj; -} - -#define wxPageSetupData_SetPaperSize(_swigobj,_swigarg0) (_swigobj->SetPaperSize(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetPaperSize(PyObject *self, PyObject *args) { - PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; wxPoint * _arg1; char * _argc0 = 0; char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"ss:wxPageSetupData_SetPaperSize",&_argc0,&_argc1)) + if(!PyArg_ParseTuple(args,"ss:wxPageSetupDialogData_SetMarginTopLeft",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetPaperSize. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetMarginTopLeft. Expected _wxPageSetupDialogData_p."); return NULL; } } if (_argc1) { if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPoint_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupData_SetPaperSize. Expected _wxPoint_p."); + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMarginTopLeft. Expected _wxPoint_p."); return NULL; } } - wxPageSetupData_SetPaperSize(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetMarginTopLeft(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_SetMarginTopLeft(_swigobj,_swigarg0) (_swigobj->SetMarginTopLeft(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetMarginTopLeft(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetMarginBottomRight(_swigobj,_swigarg0) (_swigobj->SetMarginBottomRight(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetMarginBottomRight(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; wxPoint * _arg1; char * _argc0 = 0; char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"ss:wxPageSetupData_SetMarginTopLeft",&_argc0,&_argc1)) + if(!PyArg_ParseTuple(args,"ss:wxPageSetupDialogData_SetMarginBottomRight",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetMarginTopLeft. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetMarginBottomRight. Expected _wxPageSetupDialogData_p."); return NULL; } } if (_argc1) { if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPoint_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupData_SetMarginTopLeft. Expected _wxPoint_p."); + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMarginBottomRight. Expected _wxPoint_p."); return NULL; } } - wxPageSetupData_SetMarginTopLeft(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetMarginBottomRight(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_SetMarginBottomRight(_swigobj,_swigarg0) (_swigobj->SetMarginBottomRight(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetMarginBottomRight(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetMinMarginTopLeft(_swigobj,_swigarg0) (_swigobj->SetMinMarginTopLeft(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetMinMarginTopLeft(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; wxPoint * _arg1; char * _argc0 = 0; char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"ss:wxPageSetupData_SetMarginBottomRight",&_argc0,&_argc1)) + if(!PyArg_ParseTuple(args,"ss:wxPageSetupDialogData_SetMinMarginTopLeft",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetMarginBottomRight. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetMinMarginTopLeft. Expected _wxPageSetupDialogData_p."); return NULL; } } if (_argc1) { if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPoint_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupData_SetMarginBottomRight. Expected _wxPoint_p."); + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMinMarginTopLeft. Expected _wxPoint_p."); return NULL; } } - wxPageSetupData_SetMarginBottomRight(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetMinMarginTopLeft(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_SetMinMarginTopLeft(_swigobj,_swigarg0) (_swigobj->SetMinMarginTopLeft(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetMinMarginTopLeft(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetMinMarginBottomRight(_swigobj,_swigarg0) (_swigobj->SetMinMarginBottomRight(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetMinMarginBottomRight(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; + wxPageSetupDialogData * _arg0; wxPoint * _arg1; char * _argc0 = 0; char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"ss:wxPageSetupData_SetMinMarginTopLeft",&_argc0,&_argc1)) + if(!PyArg_ParseTuple(args,"ss:wxPageSetupDialogData_SetMinMarginBottomRight",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetMinMarginTopLeft. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetMinMarginBottomRight. Expected _wxPageSetupDialogData_p."); return NULL; } } if (_argc1) { if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPoint_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupData_SetMinMarginTopLeft. Expected _wxPoint_p."); + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMinMarginBottomRight. Expected _wxPoint_p."); return NULL; } } - wxPageSetupData_SetMinMarginTopLeft(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetMinMarginBottomRight(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_SetMinMarginBottomRight(_swigobj,_swigarg0) (_swigobj->SetMinMarginBottomRight(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetMinMarginBottomRight(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetPaperId(_swigobj,_swigarg0) (_swigobj->SetPaperId(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetPaperId(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; - wxPoint * _arg1; + wxPageSetupDialogData * _arg0; + wxPaperSize * _arg1; char * _argc0 = 0; char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"ss:wxPageSetupData_SetMinMarginBottomRight",&_argc0,&_argc1)) + if(!PyArg_ParseTuple(args,"ss:wxPageSetupDialogData_SetPaperId",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetMinMarginBottomRight. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetPaperId. Expected _wxPageSetupDialogData_p."); return NULL; } } if (_argc1) { - if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPoint_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupData_SetMinMarginBottomRight. Expected _wxPoint_p."); + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPaperSize_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetPaperId. Expected _wxPaperSize_p."); return NULL; } } - wxPageSetupData_SetMinMarginBottomRight(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetPaperId(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_SetOrientation(_swigobj,_swigarg0) (_swigobj->SetOrientation(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetOrientation(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetPaperSize(_swigobj,_swigarg0) (_swigobj->SetPaperSize(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetPaperSize(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; - int _arg1; + wxPageSetupDialogData * _arg0; + wxSize * _arg1; char * _argc0 = 0; + char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_SetOrientation",&_argc0,&_arg1)) + if(!PyArg_ParseTuple(args,"ss:wxPageSetupDialogData_SetPaperSize",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetOrientation. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetPaperSize. Expected _wxPageSetupDialogData_p."); return NULL; } } - wxPageSetupData_SetOrientation(_arg0,_arg1); - Py_INCREF(Py_None); + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxSize_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetPaperSize. Expected _wxSize_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetPaperSize(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPageSetupData_SetDefaultMinMargins(_swigobj,_swigarg0) (_swigobj->SetDefaultMinMargins(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetDefaultMinMargins(PyObject *self, PyObject *args) { +#define wxPageSetupDialogData_SetPrintData(_swigobj,_swigarg0) (_swigobj->SetPrintData(_swigarg0)) +static PyObject *_wrap_wxPageSetupDialogData_SetPrintData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _arg0; - bool _arg1; + wxPageSetupDialogData * _arg0; + wxPrintData * _arg1; char * _argc0 = 0; - int tempbool1; + char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_SetDefaultMinMargins",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"ss:wxPageSetupDialogData_SetPrintData",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetDefaultMinMargins. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupDialogData_SetPrintData. Expected _wxPageSetupDialogData_p."); return NULL; } } - _arg1 = (bool ) tempbool1; - wxPageSetupData_SetDefaultMinMargins(_arg0,_arg1); - Py_INCREF(Py_None); - _resultobj = Py_None; - return _resultobj; -} - -#define wxPageSetupData_SetDefaultInfo(_swigobj,_swigarg0) (_swigobj->SetDefaultInfo(_swigarg0)) -static PyObject *_wrap_wxPageSetupData_SetDefaultInfo(PyObject *self, PyObject *args) { - PyObject * _resultobj; - wxPageSetupData * _arg0; - bool _arg1; - char * _argc0 = 0; - int tempbool1; - - self = self; - if(!PyArg_ParseTuple(args,"si:wxPageSetupData_SetDefaultInfo",&_argc0,&tempbool1)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPageSetupData_SetDefaultInfo. Expected _wxPageSetupData_p."); + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPrintData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetPrintData. Expected _wxPrintData_p."); return NULL; } } - _arg1 = (bool ) tempbool1; - wxPageSetupData_SetDefaultInfo(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData_SetPrintData(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2612,7 +3041,7 @@ static PyObject *_wrap_new_wxPageSetupDialog(PyObject *self, PyObject *args) { PyObject * _resultobj; wxPageSetupDialog * _result; wxWindow * _arg0; - wxPageSetupData * _arg1 = NULL; + wxPageSetupDialogData * _arg1 = NULL; char * _argc0 = 0; char * _argc1 = 0; char _ptemp[128]; @@ -2627,13 +3056,17 @@ static PyObject *_wrap_new_wxPageSetupDialog(PyObject *self, PyObject *args) { } } if (_argc1) { - if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPageSetupData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxPageSetupDialog. Expected _wxPageSetupData_p."); + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPageSetupDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxPageSetupDialog. Expected _wxPageSetupDialogData_p."); return NULL; } } - _result = (wxPageSetupDialog *)new_wxPageSetupDialog(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPageSetupDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPageSetupDialog *)new_wxPageSetupDialog(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPageSetupDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2641,7 +3074,7 @@ static PyObject *_wrap_new_wxPageSetupDialog(PyObject *self, PyObject *args) { #define wxPageSetupDialog_GetPageSetupData(_swigobj) (_swigobj->GetPageSetupData()) static PyObject *_wrap_wxPageSetupDialog_GetPageSetupData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPageSetupData * _result; + wxPageSetupDialogData * _result; wxPageSetupDialog * _arg0; char * _argc0 = 0; char _ptemp[128]; @@ -2655,9 +3088,13 @@ static PyObject *_wrap_wxPageSetupDialog_GetPageSetupData(PyObject *self, PyObje return NULL; } } - wxPageSetupData & _result_ref = wxPageSetupDialog_GetPageSetupData(_arg0); - _result = (wxPageSetupData *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPageSetupData_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPageSetupDialogData & _result_ref = wxPageSetupDialog_GetPageSetupData(_arg0); + _result = (wxPageSetupDialogData *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPageSetupDialogData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2678,511 +3115,642 @@ static PyObject *_wrap_wxPageSetupDialog_ShowModal(PyObject *self, PyObject *arg return NULL; } } - _result = (int )wxPageSetupDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPageSetupDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define new_wxPrintData() (new wxPrintData()) -static PyObject *_wrap_new_wxPrintData(PyObject *self, PyObject *args) { +#define new_wxPrintDialogData() (new wxPrintDialogData()) +static PyObject *_wrap_new_wxPrintDialogData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _result; + wxPrintDialogData * _result; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,":new_wxPrintData")) + if(!PyArg_ParseTuple(args,":new_wxPrintDialogData")) return NULL; - _result = (wxPrintData *)new_wxPrintData(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintData_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPrintDialogData *)new_wxPrintDialogData(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintDialogData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define delete_wxPrintData(_swigobj) (delete _swigobj) -static PyObject *_wrap_delete_wxPrintData(PyObject *self, PyObject *args) { +#define delete_wxPrintDialogData(_swigobj) (delete _swigobj) +static PyObject *_wrap_delete_wxPrintDialogData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:delete_wxPrintData",&_argc0)) + if(!PyArg_ParseTuple(args,"s:delete_wxPrintDialogData",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxPrintData. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxPrintDialogData. Expected _wxPrintDialogData_p."); return NULL; } } - delete_wxPrintData(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxPrintDialogData(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_EnableHelp(_swigobj,_swigarg0) (_swigobj->EnableHelp(_swigarg0)) -static PyObject *_wrap_wxPrintData_EnableHelp(PyObject *self, PyObject *args) { +#define wxPrintDialogData_EnableHelp(_swigobj,_swigarg0) (_swigobj->EnableHelp(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_EnableHelp(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_EnableHelp",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_EnableHelp",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_EnableHelp. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_EnableHelp. Expected _wxPrintDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPrintData_EnableHelp(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_EnableHelp(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_EnablePageNumbers(_swigobj,_swigarg0) (_swigobj->EnablePageNumbers(_swigarg0)) -static PyObject *_wrap_wxPrintData_EnablePageNumbers(PyObject *self, PyObject *args) { +#define wxPrintDialogData_EnablePageNumbers(_swigobj,_swigarg0) (_swigobj->EnablePageNumbers(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_EnablePageNumbers(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_EnablePageNumbers",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_EnablePageNumbers",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_EnablePageNumbers. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_EnablePageNumbers. Expected _wxPrintDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPrintData_EnablePageNumbers(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_EnablePageNumbers(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_EnablePrintToFile(_swigobj,_swigarg0) (_swigobj->EnablePrintToFile(_swigarg0)) -static PyObject *_wrap_wxPrintData_EnablePrintToFile(PyObject *self, PyObject *args) { +#define wxPrintDialogData_EnablePrintToFile(_swigobj,_swigarg0) (_swigobj->EnablePrintToFile(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_EnablePrintToFile(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_EnablePrintToFile",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_EnablePrintToFile",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_EnablePrintToFile. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_EnablePrintToFile. Expected _wxPrintDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPrintData_EnablePrintToFile(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_EnablePrintToFile(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_EnableSelection(_swigobj,_swigarg0) (_swigobj->EnableSelection(_swigarg0)) -static PyObject *_wrap_wxPrintData_EnableSelection(PyObject *self, PyObject *args) { +#define wxPrintDialogData_EnableSelection(_swigobj,_swigarg0) (_swigobj->EnableSelection(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_EnableSelection(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_EnableSelection",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_EnableSelection",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_EnableSelection. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_EnableSelection. Expected _wxPrintDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPrintData_EnableSelection(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_EnableSelection(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_GetAllPages(_swigobj) (_swigobj->GetAllPages()) -static PyObject *_wrap_wxPrintData_GetAllPages(PyObject *self, PyObject *args) { +#define wxPrintDialogData_GetAllPages(_swigobj) (_swigobj->GetAllPages()) +static PyObject *_wrap_wxPrintDialogData_GetAllPages(PyObject *self, PyObject *args) { PyObject * _resultobj; bool _result; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetAllPages",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetAllPages",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetAllPages. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetAllPages. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (bool )wxPrintData_GetAllPages(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPrintDialogData_GetAllPages(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define wxPrintData_GetCollate(_swigobj) (_swigobj->GetCollate()) -static PyObject *_wrap_wxPrintData_GetCollate(PyObject *self, PyObject *args) { +#define wxPrintDialogData_GetCollate(_swigobj) (_swigobj->GetCollate()) +static PyObject *_wrap_wxPrintDialogData_GetCollate(PyObject *self, PyObject *args) { PyObject * _resultobj; bool _result; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetCollate",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetCollate",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetCollate. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetCollate. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (bool )wxPrintData_GetCollate(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPrintDialogData_GetCollate(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define wxPrintData_GetFromPage(_swigobj) (_swigobj->GetFromPage()) -static PyObject *_wrap_wxPrintData_GetFromPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_GetFromPage(_swigobj) (_swigobj->GetFromPage()) +static PyObject *_wrap_wxPrintDialogData_GetFromPage(PyObject *self, PyObject *args) { PyObject * _resultobj; int _result; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetFromPage",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetFromPage",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetFromPage. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetFromPage. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (int )wxPrintData_GetFromPage(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPrintDialogData_GetFromPage(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define wxPrintData_GetMaxPage(_swigobj) (_swigobj->GetMaxPage()) -static PyObject *_wrap_wxPrintData_GetMaxPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_GetMaxPage(_swigobj) (_swigobj->GetMaxPage()) +static PyObject *_wrap_wxPrintDialogData_GetMaxPage(PyObject *self, PyObject *args) { PyObject * _resultobj; int _result; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetMaxPage",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetMaxPage",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetMaxPage. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetMaxPage. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (int )wxPrintData_GetMaxPage(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPrintDialogData_GetMaxPage(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define wxPrintData_GetMinPage(_swigobj) (_swigobj->GetMinPage()) -static PyObject *_wrap_wxPrintData_GetMinPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_GetMinPage(_swigobj) (_swigobj->GetMinPage()) +static PyObject *_wrap_wxPrintDialogData_GetMinPage(PyObject *self, PyObject *args) { PyObject * _resultobj; int _result; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetMinPage",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetMinPage",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetMinPage. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetMinPage. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (int )wxPrintData_GetMinPage(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPrintDialogData_GetMinPage(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define wxPrintData_GetNoCopies(_swigobj) (_swigobj->GetNoCopies()) -static PyObject *_wrap_wxPrintData_GetNoCopies(PyObject *self, PyObject *args) { +#define wxPrintDialogData_GetNoCopies(_swigobj) (_swigobj->GetNoCopies()) +static PyObject *_wrap_wxPrintDialogData_GetNoCopies(PyObject *self, PyObject *args) { PyObject * _resultobj; int _result; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetNoCopies",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetNoCopies",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetNoCopies. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetNoCopies. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (int )wxPrintData_GetNoCopies(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPrintDialogData_GetNoCopies(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define wxPrintData_GetOrientation(_swigobj) (_swigobj->GetOrientation()) -static PyObject *_wrap_wxPrintData_GetOrientation(PyObject *self, PyObject *args) { +#define wxPrintDialogData_GetPrintData(_swigobj) (_swigobj->GetPrintData()) +static PyObject *_wrap_wxPrintDialogData_GetPrintData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPrintData * _result; + wxPrintDialogData * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetPrintData",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetPrintData. Expected _wxPrintDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintData & _result_ref = wxPrintDialogData_GetPrintData(_arg0); + _result = (wxPrintData *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintData_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxPrintDialogData_GetPrintToFile(_swigobj) (_swigobj->GetPrintToFile()) +static PyObject *_wrap_wxPrintDialogData_GetPrintToFile(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxPrintDialogData * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetPrintToFile",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetPrintToFile. Expected _wxPrintDialogData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPrintDialogData_GetPrintToFile(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxPrintDialogData_GetToPage(_swigobj) (_swigobj->GetToPage()) +static PyObject *_wrap_wxPrintDialogData_GetToPage(PyObject *self, PyObject *args) { PyObject * _resultobj; int _result; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetOrientation",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialogData_GetToPage",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetOrientation. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_GetToPage. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (int )wxPrintData_GetOrientation(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPrintDialogData_GetToPage(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define wxPrintData_GetToPage(_swigobj) (_swigobj->GetToPage()) -static PyObject *_wrap_wxPrintData_GetToPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetCollate(_swigobj,_swigarg0) (_swigobj->SetCollate(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetCollate(PyObject *self, PyObject *args) { PyObject * _resultobj; - int _result; - wxPrintData * _arg0; - char * _argc0 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintData_GetToPage",&_argc0)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_GetToPage. Expected _wxPrintData_p."); - return NULL; - } - } - _result = (int )wxPrintData_GetToPage(_arg0); - _resultobj = Py_BuildValue("i",_result); - return _resultobj; -} - -#define wxPrintData_SetCollate(_swigobj,_swigarg0) (_swigobj->SetCollate(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetCollate(PyObject *self, PyObject *args) { - PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetCollate",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetCollate",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetCollate. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetCollate. Expected _wxPrintDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPrintData_SetCollate(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetCollate(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetFromPage(_swigobj,_swigarg0) (_swigobj->SetFromPage(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetFromPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetFromPage(_swigobj,_swigarg0) (_swigobj->SetFromPage(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetFromPage(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; int _arg1; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetFromPage",&_argc0,&_arg1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetFromPage",&_argc0,&_arg1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetFromPage. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetFromPage. Expected _wxPrintDialogData_p."); return NULL; } } - wxPrintData_SetFromPage(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetFromPage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetMaxPage(_swigobj,_swigarg0) (_swigobj->SetMaxPage(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetMaxPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetMaxPage(_swigobj,_swigarg0) (_swigobj->SetMaxPage(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetMaxPage(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; int _arg1; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetMaxPage",&_argc0,&_arg1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetMaxPage",&_argc0,&_arg1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetMaxPage. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetMaxPage. Expected _wxPrintDialogData_p."); return NULL; } } - wxPrintData_SetMaxPage(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetMaxPage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetMinPage(_swigobj,_swigarg0) (_swigobj->SetMinPage(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetMinPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetMinPage(_swigobj,_swigarg0) (_swigobj->SetMinPage(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetMinPage(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; int _arg1; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetMinPage",&_argc0,&_arg1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetMinPage",&_argc0,&_arg1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetMinPage. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetMinPage. Expected _wxPrintDialogData_p."); return NULL; } } - wxPrintData_SetMinPage(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetMinPage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetOrientation(_swigobj,_swigarg0) (_swigobj->SetOrientation(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetOrientation(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetNoCopies(_swigobj,_swigarg0) (_swigobj->SetNoCopies(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetNoCopies(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; int _arg1; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetOrientation",&_argc0,&_arg1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetNoCopies",&_argc0,&_arg1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetOrientation. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetNoCopies. Expected _wxPrintDialogData_p."); return NULL; } } - wxPrintData_SetOrientation(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetNoCopies(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetNoCopies(_swigobj,_swigarg0) (_swigobj->SetNoCopies(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetNoCopies(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetPrintData(_swigobj,_swigarg0) (_swigobj->SetPrintData(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetPrintData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; - int _arg1; + wxPrintDialogData * _arg0; + wxPrintData * _arg1; char * _argc0 = 0; + char * _argc1 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetNoCopies",&_argc0,&_arg1)) + if(!PyArg_ParseTuple(args,"ss:wxPrintDialogData_SetPrintData",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetNoCopies. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetPrintData. Expected _wxPrintDialogData_p."); return NULL; } } - wxPrintData_SetNoCopies(_arg0,_arg1); - Py_INCREF(Py_None); + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPrintData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPrintDialogData_SetPrintData. Expected _wxPrintData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetPrintData(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetPrintToFile(_swigobj,_swigarg0) (_swigobj->SetPrintToFile(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetPrintToFile(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetPrintToFile(_swigobj,_swigarg0) (_swigobj->SetPrintToFile(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetPrintToFile(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetPrintToFile",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetPrintToFile",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetPrintToFile. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetPrintToFile. Expected _wxPrintDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPrintData_SetPrintToFile(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetPrintToFile(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetSetupDialog(_swigobj,_swigarg0) (_swigobj->SetSetupDialog(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetSetupDialog(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetSetupDialog(_swigobj,_swigarg0) (_swigobj->SetSetupDialog(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetSetupDialog(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; bool _arg1; char * _argc0 = 0; int tempbool1; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetSetupDialog",&_argc0,&tempbool1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetSetupDialog",&_argc0,&tempbool1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetSetupDialog. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetSetupDialog. Expected _wxPrintDialogData_p."); return NULL; } } _arg1 = (bool ) tempbool1; - wxPrintData_SetSetupDialog(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetSetupDialog(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } -#define wxPrintData_SetToPage(_swigobj,_swigarg0) (_swigobj->SetToPage(_swigarg0)) -static PyObject *_wrap_wxPrintData_SetToPage(PyObject *self, PyObject *args) { +#define wxPrintDialogData_SetToPage(_swigobj,_swigarg0) (_swigobj->SetToPage(_swigarg0)) +static PyObject *_wrap_wxPrintDialogData_SetToPage(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _arg0; + wxPrintDialogData * _arg0; int _arg1; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"si:wxPrintData_SetToPage",&_argc0,&_arg1)) + if(!PyArg_ParseTuple(args,"si:wxPrintDialogData_SetToPage",&_argc0,&_arg1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintData_SetToPage. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialogData_SetToPage. Expected _wxPrintDialogData_p."); return NULL; } } - wxPrintData_SetToPage(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData_SetToPage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3224,7 +3792,7 @@ static PyObject *_wrap_new_wxPrintDialog(PyObject *self, PyObject *args) { PyObject * _resultobj; wxPrintDialog * _result; wxWindow * _arg0; - wxPrintData * _arg1 = NULL; + wxPrintDialogData * _arg1 = NULL; char * _argc0 = 0; char * _argc1 = 0; char _ptemp[128]; @@ -3239,37 +3807,45 @@ static PyObject *_wrap_new_wxPrintDialog(PyObject *self, PyObject *args) { } } if (_argc1) { - if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPrintData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxPrintDialog. Expected _wxPrintData_p."); + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPrintDialogData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxPrintDialog. Expected _wxPrintDialogData_p."); return NULL; } } - _result = (wxPrintDialog *)new_wxPrintDialog(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPrintDialog *)new_wxPrintDialog(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define wxPrintDialog_GetPrintData(_swigobj) (_swigobj->GetPrintData()) -static PyObject *_wrap_wxPrintDialog_GetPrintData(PyObject *self, PyObject *args) { +#define wxPrintDialog_GetPrintDialogData(_swigobj) (_swigobj->GetPrintDialogData()) +static PyObject *_wrap_wxPrintDialog_GetPrintDialogData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxPrintData * _result; + wxPrintDialogData * _result; wxPrintDialog * _arg0; char * _argc0 = 0; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,"s:wxPrintDialog_GetPrintData",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxPrintDialog_GetPrintDialogData",&_argc0)) return NULL; if (_argc0) { if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPrintDialog_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialog_GetPrintData. Expected _wxPrintDialog_p."); + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPrintDialog_GetPrintDialogData. Expected _wxPrintDialog_p."); return NULL; } } - wxPrintData & _result_ref = wxPrintDialog_GetPrintData(_arg0); - _result = (wxPrintData *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintData_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPrintDialogData & _result_ref = wxPrintDialog_GetPrintDialogData(_arg0); + _result = (wxPrintDialogData *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrintDialogData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3291,8 +3867,12 @@ static PyObject *_wrap_wxPrintDialog_GetPrintDC(PyObject *self, PyObject *args) return NULL; } } - _result = (wxDC *)wxPrintDialog_GetPrintDC(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxDC *)wxPrintDialog_GetPrintDC(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3313,8 +3893,12 @@ static PyObject *_wrap_wxPrintDialog_ShowModal(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPrintDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPrintDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3378,8 +3962,12 @@ static PyObject *_wrap_new_wxMessageDialog(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMessageDialog *)new_wxMessageDialog(_arg0,_arg1,_arg2,_arg3,*_arg4); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMessageDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMessageDialog *)new_wxMessageDialog(_arg0,_arg1,_arg2,_arg3,*_arg4); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMessageDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3400,8 +3988,12 @@ static PyObject *_wrap_wxMessageDialog_ShowModal(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxMessageDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMessageDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3410,62 +4002,65 @@ static PyMethodDef cmndlgscMethods[] = { { "new_wxMessageDialog", _wrap_new_wxMessageDialog, 1 }, { "wxPrintDialog_ShowModal", _wrap_wxPrintDialog_ShowModal, 1 }, { "wxPrintDialog_GetPrintDC", _wrap_wxPrintDialog_GetPrintDC, 1 }, - { "wxPrintDialog_GetPrintData", _wrap_wxPrintDialog_GetPrintData, 1 }, + { "wxPrintDialog_GetPrintDialogData", _wrap_wxPrintDialog_GetPrintDialogData, 1 }, { "new_wxPrintDialog", _wrap_new_wxPrintDialog, 1 }, - { "wxPrintData_SetToPage", _wrap_wxPrintData_SetToPage, 1 }, - { "wxPrintData_SetSetupDialog", _wrap_wxPrintData_SetSetupDialog, 1 }, - { "wxPrintData_SetPrintToFile", _wrap_wxPrintData_SetPrintToFile, 1 }, - { "wxPrintData_SetNoCopies", _wrap_wxPrintData_SetNoCopies, 1 }, - { "wxPrintData_SetOrientation", _wrap_wxPrintData_SetOrientation, 1 }, - { "wxPrintData_SetMinPage", _wrap_wxPrintData_SetMinPage, 1 }, - { "wxPrintData_SetMaxPage", _wrap_wxPrintData_SetMaxPage, 1 }, - { "wxPrintData_SetFromPage", _wrap_wxPrintData_SetFromPage, 1 }, - { "wxPrintData_SetCollate", _wrap_wxPrintData_SetCollate, 1 }, - { "wxPrintData_GetToPage", _wrap_wxPrintData_GetToPage, 1 }, - { "wxPrintData_GetOrientation", _wrap_wxPrintData_GetOrientation, 1 }, - { "wxPrintData_GetNoCopies", _wrap_wxPrintData_GetNoCopies, 1 }, - { "wxPrintData_GetMinPage", _wrap_wxPrintData_GetMinPage, 1 }, - { "wxPrintData_GetMaxPage", _wrap_wxPrintData_GetMaxPage, 1 }, - { "wxPrintData_GetFromPage", _wrap_wxPrintData_GetFromPage, 1 }, - { "wxPrintData_GetCollate", _wrap_wxPrintData_GetCollate, 1 }, - { "wxPrintData_GetAllPages", _wrap_wxPrintData_GetAllPages, 1 }, - { "wxPrintData_EnableSelection", _wrap_wxPrintData_EnableSelection, 1 }, - { "wxPrintData_EnablePrintToFile", _wrap_wxPrintData_EnablePrintToFile, 1 }, - { "wxPrintData_EnablePageNumbers", _wrap_wxPrintData_EnablePageNumbers, 1 }, - { "wxPrintData_EnableHelp", _wrap_wxPrintData_EnableHelp, 1 }, - { "delete_wxPrintData", _wrap_delete_wxPrintData, 1 }, - { "new_wxPrintData", _wrap_new_wxPrintData, 1 }, + { "wxPrintDialogData_SetToPage", _wrap_wxPrintDialogData_SetToPage, 1 }, + { "wxPrintDialogData_SetSetupDialog", _wrap_wxPrintDialogData_SetSetupDialog, 1 }, + { "wxPrintDialogData_SetPrintToFile", _wrap_wxPrintDialogData_SetPrintToFile, 1 }, + { "wxPrintDialogData_SetPrintData", _wrap_wxPrintDialogData_SetPrintData, 1 }, + { "wxPrintDialogData_SetNoCopies", _wrap_wxPrintDialogData_SetNoCopies, 1 }, + { "wxPrintDialogData_SetMinPage", _wrap_wxPrintDialogData_SetMinPage, 1 }, + { "wxPrintDialogData_SetMaxPage", _wrap_wxPrintDialogData_SetMaxPage, 1 }, + { "wxPrintDialogData_SetFromPage", _wrap_wxPrintDialogData_SetFromPage, 1 }, + { "wxPrintDialogData_SetCollate", _wrap_wxPrintDialogData_SetCollate, 1 }, + { "wxPrintDialogData_GetToPage", _wrap_wxPrintDialogData_GetToPage, 1 }, + { "wxPrintDialogData_GetPrintToFile", _wrap_wxPrintDialogData_GetPrintToFile, 1 }, + { "wxPrintDialogData_GetPrintData", _wrap_wxPrintDialogData_GetPrintData, 1 }, + { "wxPrintDialogData_GetNoCopies", _wrap_wxPrintDialogData_GetNoCopies, 1 }, + { "wxPrintDialogData_GetMinPage", _wrap_wxPrintDialogData_GetMinPage, 1 }, + { "wxPrintDialogData_GetMaxPage", _wrap_wxPrintDialogData_GetMaxPage, 1 }, + { "wxPrintDialogData_GetFromPage", _wrap_wxPrintDialogData_GetFromPage, 1 }, + { "wxPrintDialogData_GetCollate", _wrap_wxPrintDialogData_GetCollate, 1 }, + { "wxPrintDialogData_GetAllPages", _wrap_wxPrintDialogData_GetAllPages, 1 }, + { "wxPrintDialogData_EnableSelection", _wrap_wxPrintDialogData_EnableSelection, 1 }, + { "wxPrintDialogData_EnablePrintToFile", _wrap_wxPrintDialogData_EnablePrintToFile, 1 }, + { "wxPrintDialogData_EnablePageNumbers", _wrap_wxPrintDialogData_EnablePageNumbers, 1 }, + { "wxPrintDialogData_EnableHelp", _wrap_wxPrintDialogData_EnableHelp, 1 }, + { "delete_wxPrintDialogData", _wrap_delete_wxPrintDialogData, 1 }, + { "new_wxPrintDialogData", _wrap_new_wxPrintDialogData, 1 }, { "wxPageSetupDialog_ShowModal", _wrap_wxPageSetupDialog_ShowModal, 1 }, { "wxPageSetupDialog_GetPageSetupData", _wrap_wxPageSetupDialog_GetPageSetupData, 1 }, { "new_wxPageSetupDialog", _wrap_new_wxPageSetupDialog, 1 }, - { "wxPageSetupData_SetDefaultInfo", _wrap_wxPageSetupData_SetDefaultInfo, 1 }, - { "wxPageSetupData_SetDefaultMinMargins", _wrap_wxPageSetupData_SetDefaultMinMargins, 1 }, - { "wxPageSetupData_SetOrientation", _wrap_wxPageSetupData_SetOrientation, 1 }, - { "wxPageSetupData_SetMinMarginBottomRight", _wrap_wxPageSetupData_SetMinMarginBottomRight, 1 }, - { "wxPageSetupData_SetMinMarginTopLeft", _wrap_wxPageSetupData_SetMinMarginTopLeft, 1 }, - { "wxPageSetupData_SetMarginBottomRight", _wrap_wxPageSetupData_SetMarginBottomRight, 1 }, - { "wxPageSetupData_SetMarginTopLeft", _wrap_wxPageSetupData_SetMarginTopLeft, 1 }, - { "wxPageSetupData_SetPaperSize", _wrap_wxPageSetupData_SetPaperSize, 1 }, - { "wxPageSetupData_GetDefaultInfo", _wrap_wxPageSetupData_GetDefaultInfo, 1 }, - { "wxPageSetupData_GetEnableHelp", _wrap_wxPageSetupData_GetEnableHelp, 1 }, - { "wxPageSetupData_GetEnablePrinter", _wrap_wxPageSetupData_GetEnablePrinter, 1 }, - { "wxPageSetupData_GetEnablePaper", _wrap_wxPageSetupData_GetEnablePaper, 1 }, - { "wxPageSetupData_GetEnableOrientation", _wrap_wxPageSetupData_GetEnableOrientation, 1 }, - { "wxPageSetupData_GetEnableMargins", _wrap_wxPageSetupData_GetEnableMargins, 1 }, - { "wxPageSetupData_GetDefaultMinMargins", _wrap_wxPageSetupData_GetDefaultMinMargins, 1 }, - { "wxPageSetupData_GetOrientation", _wrap_wxPageSetupData_GetOrientation, 1 }, - { "wxPageSetupData_GetMinMarginBottomRight", _wrap_wxPageSetupData_GetMinMarginBottomRight, 1 }, - { "wxPageSetupData_GetMinMarginTopLeft", _wrap_wxPageSetupData_GetMinMarginTopLeft, 1 }, - { "wxPageSetupData_GetMarginBottomRight", _wrap_wxPageSetupData_GetMarginBottomRight, 1 }, - { "wxPageSetupData_GetMarginTopLeft", _wrap_wxPageSetupData_GetMarginTopLeft, 1 }, - { "wxPageSetupData_GetPaperSize", _wrap_wxPageSetupData_GetPaperSize, 1 }, - { "wxPageSetupData_EnablePrinter", _wrap_wxPageSetupData_EnablePrinter, 1 }, - { "wxPageSetupData_EnablePaper", _wrap_wxPageSetupData_EnablePaper, 1 }, - { "wxPageSetupData_EnableOrientation", _wrap_wxPageSetupData_EnableOrientation, 1 }, - { "wxPageSetupData_EnableMargins", _wrap_wxPageSetupData_EnableMargins, 1 }, - { "wxPageSetupData_EnableHelp", _wrap_wxPageSetupData_EnableHelp, 1 }, - { "delete_wxPageSetupData", _wrap_delete_wxPageSetupData, 1 }, - { "new_wxPageSetupData", _wrap_new_wxPageSetupData, 1 }, + { "wxPageSetupDialogData_SetPrintData", _wrap_wxPageSetupDialogData_SetPrintData, 1 }, + { "wxPageSetupDialogData_SetPaperSize", _wrap_wxPageSetupDialogData_SetPaperSize, 1 }, + { "wxPageSetupDialogData_SetPaperId", _wrap_wxPageSetupDialogData_SetPaperId, 1 }, + { "wxPageSetupDialogData_SetMinMarginBottomRight", _wrap_wxPageSetupDialogData_SetMinMarginBottomRight, 1 }, + { "wxPageSetupDialogData_SetMinMarginTopLeft", _wrap_wxPageSetupDialogData_SetMinMarginTopLeft, 1 }, + { "wxPageSetupDialogData_SetMarginBottomRight", _wrap_wxPageSetupDialogData_SetMarginBottomRight, 1 }, + { "wxPageSetupDialogData_SetMarginTopLeft", _wrap_wxPageSetupDialogData_SetMarginTopLeft, 1 }, + { "wxPageSetupDialogData_SetDefaultMinMargins", _wrap_wxPageSetupDialogData_SetDefaultMinMargins, 1 }, + { "wxPageSetupDialogData_SetDefaultInfo", _wrap_wxPageSetupDialogData_SetDefaultInfo, 1 }, + { "wxPageSetupDialogData_GetPrintData", _wrap_wxPageSetupDialogData_GetPrintData, 1 }, + { "wxPageSetupDialogData_GetPaperSize", _wrap_wxPageSetupDialogData_GetPaperSize, 1 }, + { "wxPageSetupDialogData_GetPaperId", _wrap_wxPageSetupDialogData_GetPaperId, 1 }, + { "wxPageSetupDialogData_GetMinMarginBottomRight", _wrap_wxPageSetupDialogData_GetMinMarginBottomRight, 1 }, + { "wxPageSetupDialogData_GetMinMarginTopLeft", _wrap_wxPageSetupDialogData_GetMinMarginTopLeft, 1 }, + { "wxPageSetupDialogData_GetMarginBottomRight", _wrap_wxPageSetupDialogData_GetMarginBottomRight, 1 }, + { "wxPageSetupDialogData_GetMarginTopLeft", _wrap_wxPageSetupDialogData_GetMarginTopLeft, 1 }, + { "wxPageSetupDialogData_GetDefaultInfo", _wrap_wxPageSetupDialogData_GetDefaultInfo, 1 }, + { "wxPageSetupDialogData_GetEnableHelp", _wrap_wxPageSetupDialogData_GetEnableHelp, 1 }, + { "wxPageSetupDialogData_GetEnablePrinter", _wrap_wxPageSetupDialogData_GetEnablePrinter, 1 }, + { "wxPageSetupDialogData_GetEnablePaper", _wrap_wxPageSetupDialogData_GetEnablePaper, 1 }, + { "wxPageSetupDialogData_GetEnableOrientation", _wrap_wxPageSetupDialogData_GetEnableOrientation, 1 }, + { "wxPageSetupDialogData_GetEnableMargins", _wrap_wxPageSetupDialogData_GetEnableMargins, 1 }, + { "wxPageSetupDialogData_GetDefaultMinMargins", _wrap_wxPageSetupDialogData_GetDefaultMinMargins, 1 }, + { "wxPageSetupDialogData_EnablePrinter", _wrap_wxPageSetupDialogData_EnablePrinter, 1 }, + { "wxPageSetupDialogData_EnablePaper", _wrap_wxPageSetupDialogData_EnablePaper, 1 }, + { "wxPageSetupDialogData_EnableOrientation", _wrap_wxPageSetupDialogData_EnableOrientation, 1 }, + { "wxPageSetupDialogData_EnableMargins", _wrap_wxPageSetupDialogData_EnableMargins, 1 }, + { "wxPageSetupDialogData_EnableHelp", _wrap_wxPageSetupDialogData_EnableHelp, 1 }, + { "delete_wxPageSetupDialogData", _wrap_delete_wxPageSetupDialogData, 1 }, + { "new_wxPageSetupDialogData", _wrap_new_wxPageSetupDialogData, 1 }, { "wxFontDialog_ShowModal", _wrap_wxFontDialog_ShowModal, 1 }, { "wxFontDialog_GetFontData", _wrap_wxFontDialog_GetFontData, 1 }, { "new_wxFontDialog", _wrap_new_wxFontDialog, 1 }, @@ -3570,15 +4165,16 @@ SWIGEXPORT(void,initcmndlgsc)() { SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0); SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0); SWIG_RegisterMapping("_wxMask","_class_wxMask",0); - SWIG_RegisterMapping("_wxPageSetupData","_class_wxPageSetupData",0); SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0); SWIG_RegisterMapping("_class_wxColourData","_wxColourData",0); + SWIG_RegisterMapping("_class_wxPageSetupDialogData","_wxPageSetupDialogData",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("_wxImageList","_class_wxImageList",0); + SWIG_RegisterMapping("_class_wxPrintDialogData","_wxPrintDialogData",0); SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0); SWIG_RegisterMapping("_wxDC","_class_wxDC",0); SWIG_RegisterMapping("_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0); @@ -3606,7 +4202,6 @@ SWIGEXPORT(void,initcmndlgsc)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); - SWIG_RegisterMapping("_class_wxPageSetupData","_wxPageSetupData",0); SWIG_RegisterMapping("_wxColour","_class_wxColour",0); SWIG_RegisterMapping("_class_wxDialog","_class_wxMessageDialog",SwigwxMessageDialogTowxDialog); SWIG_RegisterMapping("_class_wxDialog","_wxMessageDialog",SwigwxMessageDialogTowxDialog); @@ -3640,7 +4235,6 @@ SWIGEXPORT(void,initcmndlgsc)() { SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0); SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0); SWIG_RegisterMapping("_wxColourDialog","_class_wxColourDialog",0); - SWIG_RegisterMapping("_wxPrintData","_class_wxPrintData",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); SWIG_RegisterMapping("_wxMessageDialog","_class_wxMessageDialog",0); SWIG_RegisterMapping("_wxTextEntryDialog","_class_wxTextEntryDialog",0); @@ -3709,6 +4303,7 @@ SWIGEXPORT(void,initcmndlgsc)() { SWIG_RegisterMapping("_class_wxWindow","_class_wxColourDialog",SwigwxColourDialogTowxWindow); SWIG_RegisterMapping("_class_wxWindow","_wxColourDialog",SwigwxColourDialogTowxWindow); SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0); + SWIG_RegisterMapping("_wxPrintDialogData","_class_wxPrintDialogData",0); SWIG_RegisterMapping("_class_wxFont","_wxFont",0); SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0); SWIG_RegisterMapping("_wxSingleChoiceDialog","_class_wxSingleChoiceDialog",0); @@ -3805,12 +4400,12 @@ SWIGEXPORT(void,initcmndlgsc)() { SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0); SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0); SWIG_RegisterMapping("_class_wxColourDialog","_wxColourDialog",0); - SWIG_RegisterMapping("_class_wxPrintData","_wxPrintData",0); SWIG_RegisterMapping("_wxDash","_unsigned_long",0); SWIG_RegisterMapping("_wxDash","_long",0); SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0); SWIG_RegisterMapping("_class_wxTextEntryDialog","_wxTextEntryDialog",0); SWIG_RegisterMapping("_wxColourData","_class_wxColourData",0); + SWIG_RegisterMapping("_wxPageSetupDialogData","_class_wxPageSetupDialogData",0); SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0); SWIG_RegisterMapping("_class_wxFontDialog","_wxFontDialog",0); SWIG_RegisterMapping("_wxWindow","_class_wxMessageDialog",SwigwxMessageDialogTowxWindow); diff --git a/utils/wxPython/src/msw/cmndlgs.py b/utils/wxPython/src/msw/cmndlgs.py index 39dd99819e..ec9137a497 100644 --- a/utils/wxPython/src/msw/cmndlgs.py +++ b/utils/wxPython/src/msw/cmndlgs.py @@ -318,106 +318,113 @@ class wxFontDialog(wxFontDialogPtr): -class wxPageSetupDataPtr : +class wxPageSetupDialogDataPtr : def __init__(self,this): self.this = this self.thisown = 0 def __del__(self): if self.thisown == 1 : - cmndlgsc.delete_wxPageSetupData(self.this) + cmndlgsc.delete_wxPageSetupDialogData(self.this) def EnableHelp(self,arg0): - val = cmndlgsc.wxPageSetupData_EnableHelp(self.this,arg0) + val = cmndlgsc.wxPageSetupDialogData_EnableHelp(self.this,arg0) return val def EnableMargins(self,arg0): - val = cmndlgsc.wxPageSetupData_EnableMargins(self.this,arg0) + val = cmndlgsc.wxPageSetupDialogData_EnableMargins(self.this,arg0) return val def EnableOrientation(self,arg0): - val = cmndlgsc.wxPageSetupData_EnableOrientation(self.this,arg0) + val = cmndlgsc.wxPageSetupDialogData_EnableOrientation(self.this,arg0) return val def EnablePaper(self,arg0): - val = cmndlgsc.wxPageSetupData_EnablePaper(self.this,arg0) + val = cmndlgsc.wxPageSetupDialogData_EnablePaper(self.this,arg0) return val def EnablePrinter(self,arg0): - val = cmndlgsc.wxPageSetupData_EnablePrinter(self.this,arg0) + val = cmndlgsc.wxPageSetupDialogData_EnablePrinter(self.this,arg0) return val - def GetPaperSize(self): - val = cmndlgsc.wxPageSetupData_GetPaperSize(self.this) - val = wxPointPtr(val) - val.thisown = 1 + def GetDefaultMinMargins(self): + val = cmndlgsc.wxPageSetupDialogData_GetDefaultMinMargins(self.this) + return val + def GetEnableMargins(self): + val = cmndlgsc.wxPageSetupDialogData_GetEnableMargins(self.this) + return val + def GetEnableOrientation(self): + val = cmndlgsc.wxPageSetupDialogData_GetEnableOrientation(self.this) + return val + def GetEnablePaper(self): + val = cmndlgsc.wxPageSetupDialogData_GetEnablePaper(self.this) + return val + def GetEnablePrinter(self): + val = cmndlgsc.wxPageSetupDialogData_GetEnablePrinter(self.this) + return val + def GetEnableHelp(self): + val = cmndlgsc.wxPageSetupDialogData_GetEnableHelp(self.this) + return val + def GetDefaultInfo(self): + val = cmndlgsc.wxPageSetupDialogData_GetDefaultInfo(self.this) return val def GetMarginTopLeft(self): - val = cmndlgsc.wxPageSetupData_GetMarginTopLeft(self.this) + val = cmndlgsc.wxPageSetupDialogData_GetMarginTopLeft(self.this) val = wxPointPtr(val) val.thisown = 1 return val def GetMarginBottomRight(self): - val = cmndlgsc.wxPageSetupData_GetMarginBottomRight(self.this) + val = cmndlgsc.wxPageSetupDialogData_GetMarginBottomRight(self.this) val = wxPointPtr(val) val.thisown = 1 return val def GetMinMarginTopLeft(self): - val = cmndlgsc.wxPageSetupData_GetMinMarginTopLeft(self.this) + val = cmndlgsc.wxPageSetupDialogData_GetMinMarginTopLeft(self.this) val = wxPointPtr(val) val.thisown = 1 return val def GetMinMarginBottomRight(self): - val = cmndlgsc.wxPageSetupData_GetMinMarginBottomRight(self.this) + val = cmndlgsc.wxPageSetupDialogData_GetMinMarginBottomRight(self.this) val = wxPointPtr(val) val.thisown = 1 return val - def GetOrientation(self): - val = cmndlgsc.wxPageSetupData_GetOrientation(self.this) + def GetPaperId(self): + val = cmndlgsc.wxPageSetupDialogData_GetPaperId(self.this) return val - def GetDefaultMinMargins(self): - val = cmndlgsc.wxPageSetupData_GetDefaultMinMargins(self.this) + def GetPaperSize(self): + val = cmndlgsc.wxPageSetupDialogData_GetPaperSize(self.this) + val = wxSizePtr(val) + val.thisown = 1 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) + def GetPrintData(self): + val = cmndlgsc.wxPageSetupDialogData_GetPrintData(self.this) + val = wxPrintDataPtr(val) return val def SetDefaultInfo(self,arg0): - val = cmndlgsc.wxPageSetupData_SetDefaultInfo(self.this,arg0) + val = cmndlgsc.wxPageSetupDialogData_SetDefaultInfo(self.this,arg0) + return val + def SetDefaultMinMargins(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetDefaultMinMargins(self.this,arg0) + return val + def SetMarginTopLeft(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetMarginTopLeft(self.this,arg0.this) + return val + def SetMarginBottomRight(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetMarginBottomRight(self.this,arg0.this) + return val + def SetMinMarginTopLeft(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetMinMarginTopLeft(self.this,arg0.this) + return val + def SetMinMarginBottomRight(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetMinMarginBottomRight(self.this,arg0.this) + return val + def SetPaperId(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetPaperId(self.this,arg0) + return val + def SetPaperSize(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetPaperSize(self.this,arg0.this) + return val + def SetPrintData(self,arg0): + val = cmndlgsc.wxPageSetupDialogData_SetPrintData(self.this,arg0.this) return val def __repr__(self): - return "" -class wxPageSetupData(wxPageSetupDataPtr): + return "" +class wxPageSetupDialogData(wxPageSetupDialogDataPtr): def __init__(self) : - self.this = cmndlgsc.new_wxPageSetupData() + self.this = cmndlgsc.new_wxPageSetupDialogData() self.thisown = 1 @@ -429,7 +436,7 @@ class wxPageSetupDialogPtr(wxDialogPtr): self.thisown = 0 def GetPageSetupData(self): val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this) - val = wxPageSetupDataPtr(val) + val = wxPageSetupDialogDataPtr(val) return val def ShowModal(self): val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this) @@ -449,81 +456,85 @@ class wxPageSetupDialog(wxPageSetupDialogPtr): -class wxPrintDataPtr : +class wxPrintDialogDataPtr : def __init__(self,this): self.this = this self.thisown = 0 def __del__(self): if self.thisown == 1 : - cmndlgsc.delete_wxPrintData(self.this) + cmndlgsc.delete_wxPrintDialogData(self.this) def EnableHelp(self,arg0): - val = cmndlgsc.wxPrintData_EnableHelp(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_EnableHelp(self.this,arg0) return val def EnablePageNumbers(self,arg0): - val = cmndlgsc.wxPrintData_EnablePageNumbers(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_EnablePageNumbers(self.this,arg0) return val def EnablePrintToFile(self,arg0): - val = cmndlgsc.wxPrintData_EnablePrintToFile(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_EnablePrintToFile(self.this,arg0) return val def EnableSelection(self,arg0): - val = cmndlgsc.wxPrintData_EnableSelection(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_EnableSelection(self.this,arg0) return val def GetAllPages(self): - val = cmndlgsc.wxPrintData_GetAllPages(self.this) + val = cmndlgsc.wxPrintDialogData_GetAllPages(self.this) return val def GetCollate(self): - val = cmndlgsc.wxPrintData_GetCollate(self.this) + val = cmndlgsc.wxPrintDialogData_GetCollate(self.this) return val def GetFromPage(self): - val = cmndlgsc.wxPrintData_GetFromPage(self.this) + val = cmndlgsc.wxPrintDialogData_GetFromPage(self.this) return val def GetMaxPage(self): - val = cmndlgsc.wxPrintData_GetMaxPage(self.this) + val = cmndlgsc.wxPrintDialogData_GetMaxPage(self.this) return val def GetMinPage(self): - val = cmndlgsc.wxPrintData_GetMinPage(self.this) + val = cmndlgsc.wxPrintDialogData_GetMinPage(self.this) return val def GetNoCopies(self): - val = cmndlgsc.wxPrintData_GetNoCopies(self.this) + val = cmndlgsc.wxPrintDialogData_GetNoCopies(self.this) return val - def GetOrientation(self): - val = cmndlgsc.wxPrintData_GetOrientation(self.this) + def GetPrintData(self): + val = cmndlgsc.wxPrintDialogData_GetPrintData(self.this) + val = wxPrintDataPtr(val) + return val + def GetPrintToFile(self): + val = cmndlgsc.wxPrintDialogData_GetPrintToFile(self.this) return val def GetToPage(self): - val = cmndlgsc.wxPrintData_GetToPage(self.this) + val = cmndlgsc.wxPrintDialogData_GetToPage(self.this) return val def SetCollate(self,arg0): - val = cmndlgsc.wxPrintData_SetCollate(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_SetCollate(self.this,arg0) return val def SetFromPage(self,arg0): - val = cmndlgsc.wxPrintData_SetFromPage(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_SetFromPage(self.this,arg0) return val def SetMaxPage(self,arg0): - val = cmndlgsc.wxPrintData_SetMaxPage(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_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) + val = cmndlgsc.wxPrintDialogData_SetMinPage(self.this,arg0) return val def SetNoCopies(self,arg0): - val = cmndlgsc.wxPrintData_SetNoCopies(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_SetNoCopies(self.this,arg0) + return val + def SetPrintData(self,arg0): + val = cmndlgsc.wxPrintDialogData_SetPrintData(self.this,arg0.this) return val def SetPrintToFile(self,arg0): - val = cmndlgsc.wxPrintData_SetPrintToFile(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_SetPrintToFile(self.this,arg0) return val def SetSetupDialog(self,arg0): - val = cmndlgsc.wxPrintData_SetSetupDialog(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_SetSetupDialog(self.this,arg0) return val def SetToPage(self,arg0): - val = cmndlgsc.wxPrintData_SetToPage(self.this,arg0) + val = cmndlgsc.wxPrintDialogData_SetToPage(self.this,arg0) return val def __repr__(self): - return "" -class wxPrintData(wxPrintDataPtr): + return "" +class wxPrintDialogData(wxPrintDialogDataPtr): def __init__(self) : - self.this = cmndlgsc.new_wxPrintData() + self.this = cmndlgsc.new_wxPrintDialogData() self.thisown = 1 @@ -533,9 +544,9 @@ 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) + def GetPrintDialogData(self): + val = cmndlgsc.wxPrintDialog_GetPrintDialogData(self.this) + val = wxPrintDialogDataPtr(val) return val def GetPrintDC(self): val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this) diff --git a/utils/wxPython/src/msw/controls.cpp b/utils/wxPython/src/msw/controls.cpp index f0d8b1f86d..9f81dceccd 100644 --- a/utils/wxPython/src/msw/controls.cpp +++ b/utils/wxPython/src/msw/controls.cpp @@ -56,6 +56,7 @@ extern PyObject *SWIG_newvarlink(void); #include "helpers.h" #include #include +#include #ifdef __WXMSW__ #if wxUSE_OWNER_DRAWN @@ -166,8 +167,12 @@ static PyObject *_wrap_wxControl_Command(PyObject *self, PyObject *args) { return NULL; } } - wxControl_Command(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxControl_Command(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -188,8 +193,12 @@ static PyObject *_wrap_wxControl_GetLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxControl_GetLabel(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxControl_GetLabel(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -220,10 +229,14 @@ static PyObject *_wrap_wxControl_SetLabel(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxControl_SetLabel(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxControl_SetLabel(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -289,7 +302,7 @@ static PyObject *_wrap_new_wxButton(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -309,8 +322,12 @@ static PyObject *_wrap_new_wxButton(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxButton *)new_wxButton(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxButton_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxButton *)new_wxButton(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxButton_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -334,8 +351,12 @@ static PyObject *_wrap_wxButton_SetDefault(PyObject *self, PyObject *args) { return NULL; } } - wxButton_SetDefault(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxButton_SetDefault(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -424,8 +445,12 @@ static PyObject *_wrap_new_wxBitmapButton(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxBitmapButton *)new_wxBitmapButton(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmapButton_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmapButton *)new_wxBitmapButton(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmapButton_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -447,9 +472,13 @@ static PyObject *_wrap_wxBitmapButton_GetBitmapLabel(PyObject *self, PyObject *a return NULL; } } - wxBitmap & _result_ref = wxBitmapButton_GetBitmapLabel(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap & _result_ref = wxBitmapButton_GetBitmapLabel(_arg0); _result = (wxBitmap *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -471,9 +500,13 @@ static PyObject *_wrap_wxBitmapButton_GetBitmapDisabled(PyObject *self, PyObject return NULL; } } - wxBitmap & _result_ref = wxBitmapButton_GetBitmapDisabled(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap & _result_ref = wxBitmapButton_GetBitmapDisabled(_arg0); _result = (wxBitmap *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -495,9 +528,13 @@ static PyObject *_wrap_wxBitmapButton_GetBitmapFocus(PyObject *self, PyObject *a return NULL; } } - wxBitmap & _result_ref = wxBitmapButton_GetBitmapFocus(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap & _result_ref = wxBitmapButton_GetBitmapFocus(_arg0); _result = (wxBitmap *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -519,9 +556,13 @@ static PyObject *_wrap_wxBitmapButton_GetBitmapSelected(PyObject *self, PyObject return NULL; } } - wxBitmap & _result_ref = wxBitmapButton_GetBitmapSelected(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap & _result_ref = wxBitmapButton_GetBitmapSelected(_arg0); _result = (wxBitmap *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -549,8 +590,12 @@ static PyObject *_wrap_wxBitmapButton_SetBitmapDisabled(PyObject *self, PyObject return NULL; } } - wxBitmapButton_SetBitmapDisabled(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmapButton_SetBitmapDisabled(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -578,8 +623,12 @@ static PyObject *_wrap_wxBitmapButton_SetBitmapFocus(PyObject *self, PyObject *a return NULL; } } - wxBitmapButton_SetBitmapFocus(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmapButton_SetBitmapFocus(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -607,8 +656,12 @@ static PyObject *_wrap_wxBitmapButton_SetBitmapSelected(PyObject *self, PyObject return NULL; } } - wxBitmapButton_SetBitmapSelected(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmapButton_SetBitmapSelected(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -636,8 +689,12 @@ static PyObject *_wrap_wxBitmapButton_SetBitmapLabel(PyObject *self, PyObject *a return NULL; } } - wxBitmapButton_SetBitmapLabel(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmapButton_SetBitmapLabel(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -699,7 +756,7 @@ static PyObject *_wrap_new_wxCheckBox(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -719,8 +776,12 @@ static PyObject *_wrap_new_wxCheckBox(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxCheckBox *)new_wxCheckBox(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxCheckBox_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxCheckBox *)new_wxCheckBox(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxCheckBox_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -745,8 +806,12 @@ static PyObject *_wrap_wxCheckBox_GetValue(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxCheckBox_GetValue(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxCheckBox_GetValue(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -768,8 +833,12 @@ static PyObject *_wrap_wxCheckBox_SetValue(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxCheckBox_SetValue(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxCheckBox_SetValue(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -853,10 +922,19 @@ static PyObject *_wrap_new_wxChoice(PyObject *self, PyObject *args) { } } { - _arg4 = PyList_Size(_obj5); + if (_obj5) { + _arg4 = PyList_Size(_obj5); + } + else { + _arg4 = 0; + } } - _result = (wxChoice *)new_wxChoice(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7,_arg8); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxChoice_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxChoice *)new_wxChoice(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7,_arg8); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxChoice_p"); _resultobj = Py_BuildValue("s",_ptemp); { delete [] _arg5; @@ -886,10 +964,14 @@ static PyObject *_wrap_wxChoice_Append(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxChoice_Append(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxChoice_Append(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -913,8 +995,12 @@ static PyObject *_wrap_wxChoice_Clear(PyObject *self, PyObject *args) { return NULL; } } - wxChoice_Clear(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxChoice_Clear(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -942,10 +1028,14 @@ static PyObject *_wrap_wxChoice_FindString(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (int )wxChoice_FindString(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxChoice_FindString(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -969,8 +1059,12 @@ static PyObject *_wrap_wxChoice_GetColumns(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxChoice_GetColumns(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxChoice_GetColumns(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -990,8 +1084,12 @@ static PyObject *_wrap_wxChoice_GetSelection(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxChoice_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxChoice_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1012,8 +1110,12 @@ static PyObject *_wrap_wxChoice_GetString(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxChoice_GetString(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxChoice_GetString(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1038,8 +1140,12 @@ static PyObject *_wrap_wxChoice_GetStringSelection(PyObject *self, PyObject *arg return NULL; } } - _result = new wxString (wxChoice_GetStringSelection(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxChoice_GetStringSelection(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1064,8 +1170,12 @@ static PyObject *_wrap_wxChoice_Number(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxChoice_Number(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxChoice_Number(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1085,8 +1195,12 @@ static PyObject *_wrap_wxChoice_SetColumns(PyObject *self, PyObject *args) { return NULL; } } - wxChoice_SetColumns(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxChoice_SetColumns(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1107,8 +1221,12 @@ static PyObject *_wrap_wxChoice_SetSelection(PyObject *self, PyObject *args) { return NULL; } } - wxChoice_SetSelection(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxChoice_SetSelection(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1135,10 +1253,14 @@ static PyObject *_wrap_wxChoice_SetStringSelection(PyObject *self, PyObject *arg PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxChoice_SetStringSelection(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxChoice_SetStringSelection(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1227,10 +1349,19 @@ static PyObject *_wrap_new_wxComboBox(PyObject *self, PyObject *args) { } } { - _arg5 = PyList_Size(_obj6); + if (_obj6) { + _arg5 = PyList_Size(_obj6); + } + else { + _arg5 = 0; + } } - _result = (wxComboBox *)new_wxComboBox(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,*_arg8,_arg9); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxComboBox_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxComboBox *)new_wxComboBox(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,*_arg8,_arg9); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxComboBox_p"); _resultobj = Py_BuildValue("s",_ptemp); { delete [] _arg6; @@ -1260,10 +1391,14 @@ static PyObject *_wrap_wxComboBox_Append(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxComboBox_Append(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Append(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1287,8 +1422,12 @@ static PyObject *_wrap_wxComboBox_Clear(PyObject *self, PyObject *args) { return NULL; } } - wxComboBox_Clear(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Clear(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1308,8 +1447,12 @@ static PyObject *_wrap_wxComboBox_Copy(PyObject *self, PyObject *args) { return NULL; } } - wxComboBox_Copy(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Copy(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1329,8 +1472,12 @@ static PyObject *_wrap_wxComboBox_Cut(PyObject *self, PyObject *args) { return NULL; } } - wxComboBox_Cut(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Cut(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1351,8 +1498,12 @@ static PyObject *_wrap_wxComboBox_Delete(PyObject *self, PyObject *args) { return NULL; } } - wxComboBox_Delete(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Delete(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1380,10 +1531,14 @@ static PyObject *_wrap_wxComboBox_FindString(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (int )wxComboBox_FindString(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxComboBox_FindString(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -1407,8 +1562,12 @@ static PyObject *_wrap_wxComboBox_GetInsertionPoint(PyObject *self, PyObject *ar return NULL; } } - _result = (long )wxComboBox_GetInsertionPoint(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxComboBox_GetInsertionPoint(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1428,8 +1587,12 @@ static PyObject *_wrap_wxComboBox_GetLastPosition(PyObject *self, PyObject *args return NULL; } } - _result = (long )wxComboBox_GetLastPosition(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxComboBox_GetLastPosition(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1449,8 +1612,12 @@ static PyObject *_wrap_wxComboBox_GetSelection(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxComboBox_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxComboBox_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1471,8 +1638,12 @@ static PyObject *_wrap_wxComboBox_GetString(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxComboBox_GetString(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxComboBox_GetString(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1497,8 +1668,12 @@ static PyObject *_wrap_wxComboBox_GetStringSelection(PyObject *self, PyObject *a return NULL; } } - _result = new wxString (wxComboBox_GetStringSelection(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxComboBox_GetStringSelection(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1523,8 +1698,12 @@ static PyObject *_wrap_wxComboBox_GetValue(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxComboBox_GetValue(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxComboBox_GetValue(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1549,8 +1728,12 @@ static PyObject *_wrap_wxComboBox_Number(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxComboBox_Number(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxComboBox_Number(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1569,8 +1752,12 @@ static PyObject *_wrap_wxComboBox_Paste(PyObject *self, PyObject *args) { return NULL; } } - wxComboBox_Paste(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Paste(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1599,10 +1786,14 @@ static PyObject *_wrap_wxComboBox_Replace(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg3 = new wxString(PyString_AsString(_obj3)); + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); } - wxComboBox_Replace(_arg0,_arg1,_arg2,*_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Replace(_arg0,_arg1,_arg2,*_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj3) @@ -1628,8 +1819,12 @@ static PyObject *_wrap_wxComboBox_Remove(PyObject *self, PyObject *args) { return NULL; } } - wxComboBox_Remove(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_Remove(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1650,8 +1845,12 @@ static PyObject *_wrap_wxComboBox_SetInsertionPoint(PyObject *self, PyObject *ar return NULL; } } - wxComboBox_SetInsertionPoint(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_SetInsertionPoint(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1671,8 +1870,12 @@ static PyObject *_wrap_wxComboBox_SetInsertionPointEnd(PyObject *self, PyObject return NULL; } } - wxComboBox_SetInsertionPointEnd(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_SetInsertionPointEnd(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1696,8 +1899,12 @@ static PyObject *_wrap_wxComboBox_SetSelection(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxComboBox_SetSelection(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_SetSelection(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1719,8 +1926,12 @@ static PyObject *_wrap_wxComboBox_SetMark(PyObject *self, PyObject *args) { return NULL; } } - wxComboBox_SetMark(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_SetMark(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1747,10 +1958,14 @@ static PyObject *_wrap_wxComboBox_SetValue(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxComboBox_SetValue(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxComboBox_SetValue(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1828,8 +2043,12 @@ static PyObject *_wrap_new_wxGauge(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxGauge *)new_wxGauge(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxGauge_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGauge *)new_wxGauge(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGauge_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1850,8 +2069,12 @@ static PyObject *_wrap_wxGauge_GetBezelFace(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGauge_GetBezelFace(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGauge_GetBezelFace(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1871,8 +2094,12 @@ static PyObject *_wrap_wxGauge_GetRange(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGauge_GetRange(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGauge_GetRange(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1892,8 +2119,12 @@ static PyObject *_wrap_wxGauge_GetShadowWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGauge_GetShadowWidth(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGauge_GetShadowWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1913,8 +2144,12 @@ static PyObject *_wrap_wxGauge_GetValue(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGauge_GetValue(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGauge_GetValue(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1934,8 +2169,12 @@ static PyObject *_wrap_wxGauge_SetBezelFace(PyObject *self, PyObject *args) { return NULL; } } - wxGauge_SetBezelFace(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGauge_SetBezelFace(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1956,8 +2195,12 @@ static PyObject *_wrap_wxGauge_SetRange(PyObject *self, PyObject *args) { return NULL; } } - wxGauge_SetRange(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGauge_SetRange(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1978,8 +2221,12 @@ static PyObject *_wrap_wxGauge_SetShadowWidth(PyObject *self, PyObject *args) { return NULL; } } - wxGauge_SetShadowWidth(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGauge_SetShadowWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2000,8 +2247,12 @@ static PyObject *_wrap_wxGauge_SetValue(PyObject *self, PyObject *args) { return NULL; } } - wxGauge_SetValue(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGauge_SetValue(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2061,7 +2312,7 @@ static PyObject *_wrap_new_wxStaticBox(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -2075,8 +2326,12 @@ static PyObject *_wrap_new_wxStaticBox(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxStaticBox *)new_wxStaticBox(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticBox_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxStaticBox *)new_wxStaticBox(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticBox_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -2140,7 +2395,7 @@ static PyObject *_wrap_new_wxStaticText(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -2154,8 +2409,12 @@ static PyObject *_wrap_new_wxStaticText(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxStaticText *)new_wxStaticText(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticText_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxStaticText *)new_wxStaticText(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticText_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -2180,8 +2439,12 @@ static PyObject *_wrap_wxStaticText_GetLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxStaticText_GetLabel(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxStaticText_GetLabel(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -2212,10 +2475,14 @@ static PyObject *_wrap_wxStaticText_SetLabel(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxStaticText_SetLabel(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStaticText_SetLabel(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -2303,10 +2570,19 @@ static PyObject *_wrap_new_wxListBox(PyObject *self, PyObject *args) { } } { - _arg4 = PyList_Size(_obj5); + if (_obj5) { + _arg4 = PyList_Size(_obj5); + } + else { + _arg4 = 0; + } } - _result = (wxListBox *)new_wxListBox(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7,_arg8); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxListBox_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxListBox *)new_wxListBox(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7,_arg8); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxListBox_p"); _resultobj = Py_BuildValue("s",_ptemp); { delete [] _arg5; @@ -2336,10 +2612,14 @@ static PyObject *_wrap_wxListBox_Append(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxListBox_Append(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListBox_Append(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -2363,8 +2643,12 @@ static PyObject *_wrap_wxListBox_Clear(PyObject *self, PyObject *args) { return NULL; } } - wxListBox_Clear(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListBox_Clear(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2385,8 +2669,12 @@ static PyObject *_wrap_wxListBox_Delete(PyObject *self, PyObject *args) { return NULL; } } - wxListBox_Delete(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListBox_Delete(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2407,8 +2695,12 @@ static PyObject *_wrap_wxListBox_Deselect(PyObject *self, PyObject *args) { return NULL; } } - wxListBox_Deselect(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListBox_Deselect(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2436,10 +2728,14 @@ static PyObject *_wrap_wxListBox_FindString(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (int )wxListBox_FindString(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListBox_FindString(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -2463,8 +2759,47 @@ static PyObject *_wrap_wxListBox_GetSelection(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListBox_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListBox_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject * wxListBox_GetSelections(wxListBox *self) { + wxArrayInt lst; + self->GetSelections(lst); + PyObject *tup = PyTuple_New(lst.GetCount()); + for(int i=0; iAppendText(_swigarg0)) +static PyObject *_wrap_wxTextCtrl_AppendText(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxTextCtrl * _arg0; + wxString * _arg1; + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sO:wxTextCtrl_AppendText",&_argc0,&_obj1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTextCtrl_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTextCtrl_AppendText. Expected _wxTextCtrl_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTextCtrl_AppendText(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -3626,8 +4165,12 @@ static PyObject *_wrap_wxTextCtrl_XYToPosition(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxTextCtrl_XYToPosition(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxTextCtrl_XYToPosition(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3699,8 +4242,12 @@ static PyObject *_wrap_new_wxScrollBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxScrollBar *)new_wxScrollBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,*_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrollBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxScrollBar *)new_wxScrollBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,*_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrollBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3721,8 +4268,12 @@ static PyObject *_wrap_wxScrollBar_GetRange(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxScrollBar_GetRange(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxScrollBar_GetRange(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3742,8 +4293,12 @@ static PyObject *_wrap_wxScrollBar_GetPageSize(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxScrollBar_GetPageSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxScrollBar_GetPageSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3763,8 +4318,12 @@ static PyObject *_wrap_wxScrollBar_GetThumbPosition(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxScrollBar_GetThumbPosition(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxScrollBar_GetThumbPosition(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3784,8 +4343,12 @@ static PyObject *_wrap_wxScrollBar_GetThumbSize(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxScrollBar_GetThumbSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxScrollBar_GetThumbSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3805,8 +4368,12 @@ static PyObject *_wrap_wxScrollBar_SetThumbPosition(PyObject *self, PyObject *ar return NULL; } } - wxScrollBar_SetThumbPosition(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrollBar_SetThumbPosition(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3833,8 +4400,12 @@ static PyObject *_wrap_wxScrollBar_SetScrollbar(PyObject *self, PyObject *args) } } _arg5 = (bool ) tempbool5; - wxScrollBar_SetScrollbar(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrollBar_SetScrollbar(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3899,8 +4470,12 @@ static PyObject *_wrap_new_wxSpinButton(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxSpinButton *)new_wxSpinButton(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxSpinButton_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSpinButton *)new_wxSpinButton(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxSpinButton_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3921,8 +4496,12 @@ static PyObject *_wrap_wxSpinButton_GetMax(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSpinButton_GetMax(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSpinButton_GetMax(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3942,8 +4521,12 @@ static PyObject *_wrap_wxSpinButton_GetMin(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSpinButton_GetMin(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSpinButton_GetMin(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3963,8 +4546,12 @@ static PyObject *_wrap_wxSpinButton_GetValue(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSpinButton_GetValue(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSpinButton_GetValue(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3985,8 +4572,12 @@ static PyObject *_wrap_wxSpinButton_SetRange(PyObject *self, PyObject *args) { return NULL; } } - wxSpinButton_SetRange(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSpinButton_SetRange(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4007,8 +4598,12 @@ static PyObject *_wrap_wxSpinButton_SetValue(PyObject *self, PyObject *args) { return NULL; } } - wxSpinButton_SetValue(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSpinButton_SetValue(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4081,8 +4676,12 @@ static PyObject *_wrap_new_wxStaticBitmap(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxStaticBitmap *)new_wxStaticBitmap(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxStaticBitmap *)new_wxStaticBitmap(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4104,9 +4703,13 @@ static PyObject *_wrap_wxStaticBitmap_GetBitmap(PyObject *self, PyObject *args) return NULL; } } - wxBitmap & _result_ref = wxStaticBitmap_GetBitmap(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + const wxBitmap & _result_ref = wxStaticBitmap_GetBitmap(_arg0); _result = (wxBitmap *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4134,8 +4737,12 @@ static PyObject *_wrap_wxStaticBitmap_SetBitmap(PyObject *self, PyObject *args) return NULL; } } - wxStaticBitmap_SetBitmap(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStaticBitmap_SetBitmap(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4201,7 +4808,7 @@ static PyObject *_wrap_new_wxRadioBox(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -4229,10 +4836,19 @@ static PyObject *_wrap_new_wxRadioBox(PyObject *self, PyObject *args) { } } { - _arg5 = PyList_Size(_obj6); + if (_obj6) { + _arg5 = PyList_Size(_obj6); + } + else { + _arg5 = 0; + } } - _result = (wxRadioBox *)new_wxRadioBox(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,_arg8,*_arg9,_arg10); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRadioBox_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRadioBox *)new_wxRadioBox(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,_arg8,*_arg9,_arg10); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRadioBox_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -4262,8 +4878,12 @@ static PyObject *_wrap_wxRadioBox_Enable(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxRadioBox_Enable(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_Enable(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4287,8 +4907,12 @@ static PyObject *_wrap_wxRadioBox_EnableItem(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxRadioBox_EnableItem(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_EnableItem(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4316,10 +4940,14 @@ static PyObject *_wrap_wxRadioBox_FindString(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (int )wxRadioBox_FindString(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxRadioBox_FindString(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -4343,8 +4971,12 @@ static PyObject *_wrap_wxRadioBox_GetLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxRadioBox_GetLabel(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxRadioBox_GetLabel(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -4370,8 +5002,12 @@ static PyObject *_wrap_wxRadioBox_GetItemLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxRadioBox_GetItemLabel(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxRadioBox_GetItemLabel(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -4396,8 +5032,12 @@ static PyObject *_wrap_wxRadioBox_GetSelection(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxRadioBox_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxRadioBox_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4418,8 +5058,12 @@ static PyObject *_wrap_wxRadioBox_GetString(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxRadioBox_GetString(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxRadioBox_GetString(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -4444,8 +5088,12 @@ static PyObject *_wrap_wxRadioBox_GetStringSelection(PyObject *self, PyObject *a return NULL; } } - _result = new wxString (wxRadioBox_GetStringSelection(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxRadioBox_GetStringSelection(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -4470,8 +5118,12 @@ static PyObject *_wrap_wxRadioBox_Number(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxRadioBox_Number(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxRadioBox_Number(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4497,10 +5149,14 @@ static PyObject *_wrap_wxRadioBox_SetLabel(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxRadioBox_SetLabel(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_SetLabel(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -4532,10 +5188,14 @@ static PyObject *_wrap_wxRadioBox_SetItemLabel(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxRadioBox_SetItemLabel(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_SetItemLabel(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -4560,8 +5220,12 @@ static PyObject *_wrap_wxRadioBox_SetSelection(PyObject *self, PyObject *args) { return NULL; } } - wxRadioBox_SetSelection(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_SetSelection(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4588,10 +5252,14 @@ static PyObject *_wrap_wxRadioBox_SetStringSelection(PyObject *self, PyObject *a PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxRadioBox_SetStringSelection(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_SetStringSelection(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -4618,8 +5286,12 @@ static PyObject *_wrap_wxRadioBox_Show(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxRadioBox_Show(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_Show(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4643,8 +5315,12 @@ static PyObject *_wrap_wxRadioBox_ShowItem(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxRadioBox_ShowItem(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioBox_ShowItem(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4706,7 +5382,7 @@ static PyObject *_wrap_new_wxRadioButton(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -4726,8 +5402,12 @@ static PyObject *_wrap_new_wxRadioButton(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxRadioButton *)new_wxRadioButton(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRadioButton_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRadioButton *)new_wxRadioButton(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,*_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRadioButton_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -4752,8 +5432,12 @@ static PyObject *_wrap_wxRadioButton_GetValue(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxRadioButton_GetValue(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxRadioButton_GetValue(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4775,8 +5459,12 @@ static PyObject *_wrap_wxRadioButton_SetValue(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxRadioButton_SetValue(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRadioButton_SetValue(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4852,8 +5540,12 @@ static PyObject *_wrap_new_wxSlider(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxSlider *)new_wxSlider(_arg0,_arg1,_arg2,_arg3,_arg4,*_arg5,*_arg6,_arg7,*_arg8,_arg9); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxSlider_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSlider *)new_wxSlider(_arg0,_arg1,_arg2,_arg3,_arg4,*_arg5,*_arg6,_arg7,*_arg8,_arg9); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxSlider_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4873,8 +5565,12 @@ static PyObject *_wrap_wxSlider_ClearSel(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_ClearSel(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_ClearSel(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4894,8 +5590,12 @@ static PyObject *_wrap_wxSlider_ClearTicks(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_ClearTicks(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_ClearTicks(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4916,8 +5616,12 @@ static PyObject *_wrap_wxSlider_GetLineSize(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetLineSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetLineSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4937,8 +5641,12 @@ static PyObject *_wrap_wxSlider_GetMax(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetMax(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetMax(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4958,8 +5666,12 @@ static PyObject *_wrap_wxSlider_GetMin(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetMin(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetMin(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4979,8 +5691,12 @@ static PyObject *_wrap_wxSlider_GetPageSize(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetPageSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetPageSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5000,8 +5716,12 @@ static PyObject *_wrap_wxSlider_GetSelEnd(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetSelEnd(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetSelEnd(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5021,8 +5741,12 @@ static PyObject *_wrap_wxSlider_GetSelStart(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetSelStart(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetSelStart(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5042,8 +5766,12 @@ static PyObject *_wrap_wxSlider_GetThumbLength(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetThumbLength(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetThumbLength(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5063,8 +5791,12 @@ static PyObject *_wrap_wxSlider_GetTickFreq(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetTickFreq(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetTickFreq(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5084,8 +5816,12 @@ static PyObject *_wrap_wxSlider_GetValue(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxSlider_GetValue(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSlider_GetValue(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5106,8 +5842,12 @@ static PyObject *_wrap_wxSlider_SetRange(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetRange(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetRange(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5129,8 +5869,12 @@ static PyObject *_wrap_wxSlider_SetTickFreq(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetTickFreq(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetTickFreq(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5151,8 +5895,12 @@ static PyObject *_wrap_wxSlider_SetLineSize(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetLineSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetLineSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5173,8 +5921,12 @@ static PyObject *_wrap_wxSlider_SetPageSize(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetPageSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetPageSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5196,8 +5948,12 @@ static PyObject *_wrap_wxSlider_SetSelection(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetSelection(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetSelection(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5218,8 +5974,12 @@ static PyObject *_wrap_wxSlider_SetThumbLength(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetThumbLength(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetThumbLength(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5240,8 +6000,12 @@ static PyObject *_wrap_wxSlider_SetTick(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetTick(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetTick(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5262,8 +6026,12 @@ static PyObject *_wrap_wxSlider_SetValue(PyObject *self, PyObject *args) { return NULL; } } - wxSlider_SetValue(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSlider_SetValue(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5325,6 +6093,7 @@ static PyMethodDef controlscMethods[] = { { "wxScrollBar_GetRange", _wrap_wxScrollBar_GetRange, 1 }, { "new_wxScrollBar", _wrap_new_wxScrollBar, 1 }, { "wxTextCtrl_XYToPosition", _wrap_wxTextCtrl_XYToPosition, 1 }, + { "wxTextCtrl_AppendText", _wrap_wxTextCtrl_AppendText, 1 }, { "wxTextCtrl_WriteText", _wrap_wxTextCtrl_WriteText, 1 }, { "wxTextCtrl_ShowPosition", _wrap_wxTextCtrl_ShowPosition, 1 }, { "wxTextCtrl_SetValue", _wrap_wxTextCtrl_SetValue, 1 }, @@ -5364,6 +6133,7 @@ static PyMethodDef controlscMethods[] = { { "wxListBox_Number", _wrap_wxListBox_Number, 1 }, { "wxListBox_GetStringSelection", _wrap_wxListBox_GetStringSelection, 1 }, { "wxListBox_GetString", _wrap_wxListBox_GetString, 1 }, + { "wxListBox_GetSelections", _wrap_wxListBox_GetSelections, 1 }, { "wxListBox_GetSelection", _wrap_wxListBox_GetSelection, 1 }, { "wxListBox_FindString", _wrap_wxListBox_FindString, 1 }, { "wxListBox_Deselect", _wrap_wxListBox_Deselect, 1 }, @@ -5524,6 +6294,7 @@ SWIGEXPORT(void,initcontrolsc)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); @@ -5553,6 +6324,7 @@ SWIGEXPORT(void,initcontrolsc)() { SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0); SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0); diff --git a/utils/wxPython/src/msw/controls.py b/utils/wxPython/src/msw/controls.py index c6159088ec..0da356ff9a 100644 --- a/utils/wxPython/src/msw/controls.py +++ b/utils/wxPython/src/msw/controls.py @@ -383,6 +383,9 @@ class wxListBoxPtr(wxControlPtr): def GetSelection(self): val = controlsc.wxListBox_GetSelection(self.this) return val + def GetSelections(self): + val = controlsc.wxListBox_GetSelections(self.this) + return val def GetString(self,arg0): val = controlsc.wxListBox_GetString(self.this,arg0) return val @@ -536,6 +539,9 @@ class wxTextCtrlPtr(wxControlPtr): def WriteText(self,arg0): val = controlsc.wxTextCtrl_WriteText(self.this,arg0) return val + def AppendText(self,arg0): + val = controlsc.wxTextCtrl_AppendText(self.this,arg0) + return val def XYToPosition(self,arg0,arg1): val = controlsc.wxTextCtrl_XYToPosition(self.this,arg0,arg1) return val diff --git a/utils/wxPython/src/msw/controls2.cpp b/utils/wxPython/src/msw/controls2.cpp index f14682f288..2a717346f7 100644 --- a/utils/wxPython/src/msw/controls2.cpp +++ b/utils/wxPython/src/msw/controls2.cpp @@ -117,6 +117,33 @@ extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source); static char* wxStringErrorMsg = "string type is required for parameter"; extern wxValidator wxPyDefaultValidator; + +class wxPyTreeItemData : public wxTreeItemData { +public: + wxPyTreeItemData(PyObject* obj = NULL) { + if (obj == NULL) + obj = Py_None; + Py_INCREF(obj); + m_obj = obj; + } + + ~wxPyTreeItemData() { + Py_DECREF(m_obj); + } + + PyObject* GetData() { + Py_INCREF(m_obj); + return m_obj; + } + + void SetData(PyObject* obj) { + Py_DECREF(m_obj); + m_obj = obj; + Py_INCREF(obj); + } + + PyObject* m_obj; +}; #define wxListItem_m_mask_set(_swigobj,_swigval) (_swigobj->m_mask = _swigval,_swigval) static PyObject *_wrap_wxListItem_m_mask_set(PyObject *self, PyObject *args) { PyObject * _resultobj; @@ -134,8 +161,12 @@ static PyObject *_wrap_wxListItem_m_mask_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_mask_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_mask_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -155,8 +186,12 @@ static PyObject *_wrap_wxListItem_m_mask_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_mask_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_mask_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -177,8 +212,12 @@ static PyObject *_wrap_wxListItem_m_itemId_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_itemId_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_itemId_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -198,8 +237,12 @@ static PyObject *_wrap_wxListItem_m_itemId_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_itemId_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_itemId_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -220,8 +263,12 @@ static PyObject *_wrap_wxListItem_m_col_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_col_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_col_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -241,8 +288,12 @@ static PyObject *_wrap_wxListItem_m_col_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_col_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_col_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -263,8 +314,12 @@ static PyObject *_wrap_wxListItem_m_state_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_state_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_state_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -284,8 +339,12 @@ static PyObject *_wrap_wxListItem_m_state_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_state_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_state_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -306,8 +365,12 @@ static PyObject *_wrap_wxListItem_m_stateMask_set(PyObject *self, PyObject *args return NULL; } } - _result = (long )wxListItem_m_stateMask_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_stateMask_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -327,8 +390,12 @@ static PyObject *_wrap_wxListItem_m_stateMask_get(PyObject *self, PyObject *args return NULL; } } - _result = (long )wxListItem_m_stateMask_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_stateMask_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -355,10 +422,14 @@ static PyObject *_wrap_wxListItem_m_text_set(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (wxString *)wxListItem_m_text_set(_arg0,_arg1); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxString *)wxListItem_m_text_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } { @@ -384,8 +455,12 @@ static PyObject *_wrap_wxListItem_m_text_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxString *)wxListItem_m_text_get(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxString *)wxListItem_m_text_get(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } return _resultobj; @@ -408,8 +483,12 @@ static PyObject *_wrap_wxListItem_m_image_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_image_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_image_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -429,8 +508,12 @@ static PyObject *_wrap_wxListItem_m_image_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_image_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_image_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -451,8 +534,12 @@ static PyObject *_wrap_wxListItem_m_data_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_data_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_data_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -472,8 +559,12 @@ static PyObject *_wrap_wxListItem_m_data_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListItem_m_data_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListItem_m_data_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -494,8 +585,12 @@ static PyObject *_wrap_wxListItem_m_format_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_format_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_format_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -515,8 +610,12 @@ static PyObject *_wrap_wxListItem_m_format_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_format_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_format_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -537,8 +636,12 @@ static PyObject *_wrap_wxListItem_m_width_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_width_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_width_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -558,8 +661,12 @@ static PyObject *_wrap_wxListItem_m_width_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListItem_m_width_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListItem_m_width_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -572,8 +679,12 @@ static PyObject *_wrap_new_wxListItem(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxListItem")) return NULL; - _result = (wxListItem *)new_wxListItem(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxListItem *)new_wxListItem(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -593,8 +704,12 @@ static PyObject *_wrap_delete_wxListItem(PyObject *self, PyObject *args) { return NULL; } } - delete_wxListItem(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxListItem(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -632,8 +747,12 @@ static PyObject *_wrap_wxListEvent_m_code_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListEvent_m_code_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListEvent_m_code_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -653,8 +772,12 @@ static PyObject *_wrap_wxListEvent_m_code_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListEvent_m_code_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListEvent_m_code_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -675,8 +798,12 @@ static PyObject *_wrap_wxListEvent_m_itemIndex_set(PyObject *self, PyObject *arg return NULL; } } - _result = (long )wxListEvent_m_itemIndex_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListEvent_m_itemIndex_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -696,8 +823,12 @@ static PyObject *_wrap_wxListEvent_m_itemIndex_get(PyObject *self, PyObject *arg return NULL; } } - _result = (long )wxListEvent_m_itemIndex_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListEvent_m_itemIndex_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -718,8 +849,12 @@ static PyObject *_wrap_wxListEvent_m_oldItemIndex_set(PyObject *self, PyObject * return NULL; } } - _result = (long )wxListEvent_m_oldItemIndex_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListEvent_m_oldItemIndex_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -739,8 +874,12 @@ static PyObject *_wrap_wxListEvent_m_oldItemIndex_get(PyObject *self, PyObject * return NULL; } } - _result = (long )wxListEvent_m_oldItemIndex_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListEvent_m_oldItemIndex_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -761,8 +900,12 @@ static PyObject *_wrap_wxListEvent_m_col_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListEvent_m_col_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListEvent_m_col_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -782,8 +925,12 @@ static PyObject *_wrap_wxListEvent_m_col_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListEvent_m_col_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListEvent_m_col_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -806,8 +953,12 @@ static PyObject *_wrap_wxListEvent_m_cancelled_set(PyObject *self, PyObject *arg } } _arg1 = (bool ) tempbool1; - _result = (bool )wxListEvent_m_cancelled_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListEvent_m_cancelled_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -827,8 +978,12 @@ static PyObject *_wrap_wxListEvent_m_cancelled_get(PyObject *self, PyObject *arg return NULL; } } - _result = (bool )wxListEvent_m_cancelled_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListEvent_m_cancelled_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -857,8 +1012,12 @@ static PyObject *_wrap_wxListEvent_m_pointDrag_set(PyObject *self, PyObject *arg return NULL; } } - _result = (wxPoint *)wxListEvent_m_pointDrag_set(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPoint *)wxListEvent_m_pointDrag_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -880,8 +1039,12 @@ static PyObject *_wrap_wxListEvent_m_pointDrag_get(PyObject *self, PyObject *arg return NULL; } } - _result = (wxPoint *)wxListEvent_m_pointDrag_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPoint *)wxListEvent_m_pointDrag_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -911,8 +1074,12 @@ static PyObject *_wrap_wxListEvent_m_item_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxListItem *)wxListEvent_m_item_set(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxListItem *)wxListEvent_m_item_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -934,8 +1101,12 @@ static PyObject *_wrap_wxListEvent_m_item_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxListItem *)wxListEvent_m_item_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxListItem *)wxListEvent_m_item_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1008,8 +1179,12 @@ static PyObject *_wrap_new_wxListCtrl(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxListCtrl *)new_wxListCtrl(_arg0,_arg1,*_arg2,*_arg3,_arg4,*_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxListCtrl_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxListCtrl *)new_wxListCtrl(_arg0,_arg1,*_arg2,*_arg3,_arg4,*_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxListCtrl_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1031,8 +1206,12 @@ static PyObject *_wrap_wxListCtrl_Arrange(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_Arrange(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_Arrange(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1053,8 +1232,12 @@ static PyObject *_wrap_wxListCtrl_DeleteItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_DeleteItem(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_DeleteItem(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1074,8 +1257,12 @@ static PyObject *_wrap_wxListCtrl_DeleteAllItems(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxListCtrl_DeleteAllItems(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_DeleteAllItems(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1096,8 +1283,12 @@ static PyObject *_wrap_wxListCtrl_DeleteColumn(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_DeleteColumn(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_DeleteColumn(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1117,8 +1308,12 @@ static PyObject *_wrap_wxListCtrl_DeleteAllColumns(PyObject *self, PyObject *arg return NULL; } } - _result = (bool )wxListCtrl_DeleteAllColumns(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_DeleteAllColumns(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1137,8 +1332,12 @@ static PyObject *_wrap_wxListCtrl_ClearAll(PyObject *self, PyObject *args) { return NULL; } } - wxListCtrl_ClearAll(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListCtrl_ClearAll(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1161,8 +1360,12 @@ static PyObject *_wrap_wxListCtrl_EditLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxTextCtrl *)wxListCtrl_EditLabel(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTextCtrl *)wxListCtrl_EditLabel(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1186,8 +1389,12 @@ static PyObject *_wrap_wxListCtrl_EndEditLabel(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - _result = (bool )wxListCtrl_EndEditLabel(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_EndEditLabel(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1208,8 +1415,12 @@ static PyObject *_wrap_wxListCtrl_GetEditControl(PyObject *self, PyObject *args) return NULL; } } - _result = (wxTextCtrl *)wxListCtrl_GetEditControl(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTextCtrl *)wxListCtrl_GetEditControl(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1231,8 +1442,12 @@ static PyObject *_wrap_wxListCtrl_EnsureVisible(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxListCtrl_EnsureVisible(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_EnsureVisible(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1262,11 +1477,15 @@ static PyObject *_wrap_wxListCtrl_FindItem(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } _arg3 = (bool ) tempbool3; - _result = (long )wxListCtrl_FindItem(_arg0,_arg1,*_arg2,_arg3); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_FindItem(_arg0,_arg1,*_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { if (_obj2) delete _arg2; @@ -1292,8 +1511,12 @@ static PyObject *_wrap_wxListCtrl_FindItemData(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListCtrl_FindItemData(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_FindItemData(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1323,8 +1546,12 @@ static PyObject *_wrap_wxListCtrl_FindItemAtPos(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxListCtrl_FindItemAtPos(_arg0,_arg1,*_arg2,_arg3); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_FindItemAtPos(_arg0,_arg1,*_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1353,8 +1580,12 @@ static PyObject *_wrap_wxListCtrl_GetColumn(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_GetColumn(_arg0,_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_GetColumn(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1375,8 +1606,12 @@ static PyObject *_wrap_wxListCtrl_GetColumnWidth(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxListCtrl_GetColumnWidth(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListCtrl_GetColumnWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1396,8 +1631,12 @@ static PyObject *_wrap_wxListCtrl_GetCountPerPage(PyObject *self, PyObject *args return NULL; } } - _result = (int )wxListCtrl_GetCountPerPage(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListCtrl_GetCountPerPage(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1419,8 +1658,12 @@ static PyObject *_wrap_wxListCtrl_GetImageList(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxImageList *)wxListCtrl_GetImageList(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImageList *)wxListCtrl_GetImageList(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1442,8 +1685,12 @@ static PyObject *_wrap_wxListCtrl_GetItemData(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListCtrl_GetItemData(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_GetItemData(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1470,8 +1717,12 @@ static PyObject *_wrap_wxListCtrl_GetItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxListItem *)wxListCtrl_GetItem(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxListItem *)wxListCtrl_GetItem(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxListItem_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1498,8 +1749,12 @@ static PyObject *_wrap_wxListCtrl_GetItemPosition(PyObject *self, PyObject *args return NULL; } } - _result = (wxPoint *)wxListCtrl_GetItemPosition(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPoint *)wxListCtrl_GetItemPosition(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1527,8 +1782,12 @@ static PyObject *_wrap_wxListCtrl_GetItemRect(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxRect *)wxListCtrl_GetItemRect(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRect *)wxListCtrl_GetItemRect(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1551,8 +1810,12 @@ static PyObject *_wrap_wxListCtrl_GetItemState(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListCtrl_GetItemState(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListCtrl_GetItemState(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1572,8 +1835,12 @@ static PyObject *_wrap_wxListCtrl_GetItemCount(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxListCtrl_GetItemCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListCtrl_GetItemCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1596,8 +1863,12 @@ static PyObject *_wrap_wxListCtrl_GetItemSpacing(PyObject *self, PyObject *args) } } _arg1 = (bool ) tempbool1; - _result = (int )wxListCtrl_GetItemSpacing(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListCtrl_GetItemSpacing(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1618,8 +1889,12 @@ static PyObject *_wrap_wxListCtrl_GetItemText(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxListCtrl_GetItemText(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxListCtrl_GetItemText(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1647,8 +1922,12 @@ static PyObject *_wrap_wxListCtrl_GetNextItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListCtrl_GetNextItem(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_GetNextItem(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1668,8 +1947,12 @@ static PyObject *_wrap_wxListCtrl_GetSelectedItemCount(PyObject *self, PyObject return NULL; } } - _result = (int )wxListCtrl_GetSelectedItemCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxListCtrl_GetSelectedItemCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1690,8 +1973,12 @@ static PyObject *_wrap_wxListCtrl_GetTextColour(PyObject *self, PyObject *args) return NULL; } } - _result = new wxColour (wxListCtrl_GetTextColour(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxColour (wxListCtrl_GetTextColour(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1719,8 +2006,12 @@ static PyObject *_wrap_wxListCtrl_SetTextColour(PyObject *self, PyObject *args) return NULL; } } - wxListCtrl_SetTextColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListCtrl_SetTextColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1741,8 +2032,12 @@ static PyObject *_wrap_wxListCtrl_GetTopItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListCtrl_GetTopItem(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_GetTopItem(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1775,8 +2070,12 @@ static PyObject *_wrap_wxListCtrl_HitTest(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListCtrl_HitTest(_arg0,*_arg1,*_arg2); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_HitTest(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { PyObject *o; o = PyInt_FromLong((long) (*_arg2)); @@ -1810,8 +2109,12 @@ static PyObject *_wrap_wxListCtrl_InsertColumnWith(PyObject *self, PyObject *arg return NULL; } } - _result = (long )wxListCtrl_InsertColumnWith(_arg0,_arg1,*_arg2); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_InsertColumnWith(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1841,10 +2144,14 @@ static PyObject *_wrap_wxListCtrl_InsertColumn(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _result = (long )wxListCtrl_InsertColumn(_arg0,_arg1,*_arg2,_arg3,_arg4); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_InsertColumn(_arg0,_arg1,*_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { if (_obj2) delete _arg2; @@ -1876,8 +2183,12 @@ static PyObject *_wrap_wxListCtrl_InsertItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxListCtrl_InsertItem(_arg0,*_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_InsertItem(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1905,10 +2216,14 @@ static PyObject *_wrap_wxListCtrl_InsertStringItem(PyObject *self, PyObject *arg PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _result = (long )wxListCtrl_InsertStringItem(_arg0,_arg1,*_arg2); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_InsertStringItem(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { if (_obj2) delete _arg2; @@ -1934,8 +2249,12 @@ static PyObject *_wrap_wxListCtrl_InsertImageItem(PyObject *self, PyObject *args return NULL; } } - _result = (long )wxListCtrl_InsertImageItem(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_InsertImageItem(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1964,10 +2283,14 @@ static PyObject *_wrap_wxListCtrl_InsertImageStringItem(PyObject *self, PyObject PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _result = (long )wxListCtrl_InsertImageStringItem(_arg0,_arg1,*_arg2,_arg3); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_InsertImageStringItem(_arg0,_arg1,*_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { if (_obj2) delete _arg2; @@ -1993,8 +2316,12 @@ static PyObject *_wrap_wxListCtrl_ScrollList(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_ScrollList(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_ScrollList(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2021,8 +2348,12 @@ static PyObject *_wrap_wxListCtrl_SetBackgroundColour(PyObject *self, PyObject * return NULL; } } - wxListCtrl_SetBackgroundColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListCtrl_SetBackgroundColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2052,8 +2383,12 @@ static PyObject *_wrap_wxListCtrl_SetColumn(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_SetColumn(_arg0,_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_SetColumn(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2075,8 +2410,12 @@ static PyObject *_wrap_wxListCtrl_SetColumnWidth(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxListCtrl_SetColumnWidth(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_SetColumnWidth(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2104,8 +2443,12 @@ static PyObject *_wrap_wxListCtrl_SetImageList(PyObject *self, PyObject *args) { return NULL; } } - wxListCtrl_SetImageList(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListCtrl_SetImageList(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2134,8 +2477,12 @@ static PyObject *_wrap_wxListCtrl_SetItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_SetItem(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_SetItem(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2165,10 +2512,14 @@ static PyObject *_wrap_wxListCtrl_SetStringItem(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg3 = new wxString(PyString_AsString(_obj3)); + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); } - _result = (long )wxListCtrl_SetStringItem(_arg0,_arg1,_arg2,*_arg3,_arg4); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxListCtrl_SetStringItem(_arg0,_arg1,_arg2,*_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { if (_obj3) delete _arg3; @@ -2194,8 +2545,12 @@ static PyObject *_wrap_wxListCtrl_SetItemData(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_SetItemData(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_SetItemData(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2218,8 +2573,12 @@ static PyObject *_wrap_wxListCtrl_SetItemImage(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_SetItemImage(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_SetItemImage(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2248,8 +2607,12 @@ static PyObject *_wrap_wxListCtrl_SetItemPosition(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxListCtrl_SetItemPosition(_arg0,_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_SetItemPosition(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2272,8 +2635,12 @@ static PyObject *_wrap_wxListCtrl_SetItemState(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxListCtrl_SetItemState(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxListCtrl_SetItemState(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2300,10 +2667,14 @@ static PyObject *_wrap_wxListCtrl_SetItemText(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxListCtrl_SetItemText(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListCtrl_SetItemText(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -2331,8 +2702,12 @@ static PyObject *_wrap_wxListCtrl_SetSingleStyle(PyObject *self, PyObject *args) } } _arg2 = (bool ) tempbool2; - wxListCtrl_SetSingleStyle(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListCtrl_SetSingleStyle(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2353,8 +2728,12 @@ static PyObject *_wrap_wxListCtrl_SetWindowStyleFlag(PyObject *self, PyObject *a return NULL; } } - wxListCtrl_SetWindowStyleFlag(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxListCtrl_SetWindowStyleFlag(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2368,8 +2747,12 @@ static PyObject *_wrap_new_wxTreeItemId(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxTreeItemId")) return NULL; - _result = (wxTreeItemId *)new_wxTreeItemId(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTreeItemId *)new_wxTreeItemId(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2389,8 +2772,12 @@ static PyObject *_wrap_delete_wxTreeItemId(PyObject *self, PyObject *args) { return NULL; } } - delete_wxTreeItemId(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxTreeItemId(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2411,43 +2798,93 @@ static PyObject *_wrap_wxTreeItemId_IsOk(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxTreeItemId_IsOk(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTreeItemId_IsOk(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } -#define new_wxTreeItemData() (new wxTreeItemData()) +#define new_wxTreeItemData(_swigarg0) (new wxPyTreeItemData(_swigarg0)) static PyObject *_wrap_new_wxTreeItemData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxTreeItemData * _result; + wxPyTreeItemData * _result; + PyObject * _arg0 = NULL; + PyObject * _obj0 = 0; char _ptemp[128]; self = self; - if(!PyArg_ParseTuple(args,":new_wxTreeItemData")) + if(!PyArg_ParseTuple(args,"|O:new_wxTreeItemData",&_obj0)) return NULL; - _result = (wxTreeItemData *)new_wxTreeItemData(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeItemData_p"); + if (_obj0) +{ + _arg0 = _obj0; +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPyTreeItemData *)new_wxTreeItemData(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyTreeItemData_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } -#define delete_wxTreeItemData(_swigobj) (delete _swigobj) -static PyObject *_wrap_delete_wxTreeItemData(PyObject *self, PyObject *args) { +#define wxTreeItemData_GetData(_swigobj) (_swigobj->GetData()) +static PyObject *_wrap_wxTreeItemData_GetData(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxTreeItemData * _arg0; + PyObject * _result; + wxPyTreeItemData * _arg0; char * _argc0 = 0; self = self; - if(!PyArg_ParseTuple(args,"s:delete_wxTreeItemData",&_argc0)) + if(!PyArg_ParseTuple(args,"s:wxTreeItemData_GetData",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxTreeItemData. Expected _wxTreeItemData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeItemData_GetData. Expected _wxPyTreeItemData_p."); return NULL; } } - delete_wxTreeItemData(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxTreeItemData_GetData(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = _result; +} + return _resultobj; +} + +#define wxTreeItemData_SetData(_swigobj,_swigarg0) (_swigobj->SetData(_swigarg0)) +static PyObject *_wrap_wxTreeItemData_SetData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPyTreeItemData * _arg0; + PyObject * _arg1; + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sO:wxTreeItemData_SetData",&_argc0,&_obj1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeItemData_SetData. Expected _wxPyTreeItemData_p."); + return NULL; + } + } +{ + _arg1 = _obj1; +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeItemData_SetData(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2456,7 +2893,7 @@ static PyObject *_wrap_delete_wxTreeItemData(PyObject *self, PyObject *args) { static PyObject *_wrap_wxTreeItemData_GetId(PyObject *self, PyObject *args) { PyObject * _resultobj; wxTreeItemId * _result; - wxTreeItemData * _arg0; + wxPyTreeItemData * _arg0; char * _argc0 = 0; char _ptemp[128]; @@ -2464,14 +2901,18 @@ static PyObject *_wrap_wxTreeItemData_GetId(PyObject *self, PyObject *args) { if(!PyArg_ParseTuple(args,"s:wxTreeItemData_GetId",&_argc0)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeItemData_GetId. Expected _wxTreeItemData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeItemData_GetId. Expected _wxPyTreeItemData_p."); return NULL; } } - const wxTreeItemId & _result_ref = wxTreeItemData_GetId(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + const wxTreeItemId & _result_ref = wxTreeItemData_GetId(_arg0); _result = (wxTreeItemId *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeItemId_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2479,7 +2920,7 @@ static PyObject *_wrap_wxTreeItemData_GetId(PyObject *self, PyObject *args) { #define wxTreeItemData_SetId(_swigobj,_swigarg0) (_swigobj->SetId(_swigarg0)) static PyObject *_wrap_wxTreeItemData_SetId(PyObject *self, PyObject *args) { PyObject * _resultobj; - wxTreeItemData * _arg0; + wxPyTreeItemData * _arg0; wxTreeItemId * _arg1; char * _argc0 = 0; char * _argc1 = 0; @@ -2488,8 +2929,8 @@ static PyObject *_wrap_wxTreeItemData_SetId(PyObject *self, PyObject *args) { if(!PyArg_ParseTuple(args,"ss:wxTreeItemData_SetId",&_argc0,&_argc1)) return NULL; if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeItemData_SetId. Expected _wxTreeItemData_p."); + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeItemData_SetId. Expected _wxPyTreeItemData_p."); return NULL; } } @@ -2499,8 +2940,12 @@ static PyObject *_wrap_wxTreeItemData_SetId(PyObject *self, PyObject *args) { return NULL; } } - wxTreeItemData_SetId(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeItemData_SetId(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2538,8 +2983,12 @@ static PyObject *_wrap_wxTreeEvent_GetItem(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxTreeItemId (wxTreeEvent_GetItem(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeEvent_GetItem(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2561,8 +3010,12 @@ static PyObject *_wrap_wxTreeEvent_GetOldItem(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxTreeItemId (wxTreeEvent_GetOldItem(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeEvent_GetOldItem(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2584,8 +3037,12 @@ static PyObject *_wrap_wxTreeEvent_GetPoint(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxPoint (wxTreeEvent_GetPoint(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxTreeEvent_GetPoint(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2606,8 +3063,12 @@ static PyObject *_wrap_wxTreeEvent_GetCode(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxTreeEvent_GetCode(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxTreeEvent_GetCode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2626,8 +3087,12 @@ static PyObject *_wrap_wxTreeEvent_Veto(PyObject *self, PyObject *args) { return NULL; } } - wxTreeEvent_Veto(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeEvent_Veto(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2700,8 +3165,12 @@ static PyObject *_wrap_new_wxTreeCtrl(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxTreeCtrl *)new_wxTreeCtrl(_arg0,_arg1,*_arg2,*_arg3,_arg4,*_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeCtrl_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTreeCtrl *)new_wxTreeCtrl(_arg0,_arg1,*_arg2,*_arg3,_arg4,*_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeCtrl_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2723,8 +3192,12 @@ static PyObject *_wrap_wxTreeCtrl_GetCount(PyObject *self, PyObject *args) { return NULL; } } - _result = new size_t (wxTreeCtrl_GetCount(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_size_t_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new size_t (wxTreeCtrl_GetCount(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_size_t_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2745,8 +3218,12 @@ static PyObject *_wrap_wxTreeCtrl_GetIndent(PyObject *self, PyObject *args) { return NULL; } } - _result = (unsigned int )wxTreeCtrl_GetIndent(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned int )wxTreeCtrl_GetIndent(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2766,8 +3243,12 @@ static PyObject *_wrap_wxTreeCtrl_SetIndent(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_SetIndent(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetIndent(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2789,8 +3270,12 @@ static PyObject *_wrap_wxTreeCtrl_GetImageList(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxImageList *)wxTreeCtrl_GetImageList(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImageList *)wxTreeCtrl_GetImageList(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2812,8 +3297,12 @@ static PyObject *_wrap_wxTreeCtrl_GetStateImageList(PyObject *self, PyObject *ar return NULL; } } - _result = (wxImageList *)wxTreeCtrl_GetStateImageList(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImageList *)wxTreeCtrl_GetStateImageList(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2841,8 +3330,12 @@ static PyObject *_wrap_wxTreeCtrl_SetImageList(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_SetImageList(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetImageList(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2870,8 +3363,12 @@ static PyObject *_wrap_wxTreeCtrl_SetStateImageList(PyObject *self, PyObject *ar return NULL; } } - wxTreeCtrl_SetStateImageList(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetStateImageList(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2900,8 +3397,12 @@ static PyObject *_wrap_wxTreeCtrl_GetItemText(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxTreeCtrl_GetItemText(_arg0,*_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxTreeCtrl_GetItemText(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -2934,8 +3435,12 @@ static PyObject *_wrap_wxTreeCtrl_GetItemImage(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxTreeCtrl_GetItemImage(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxTreeCtrl_GetItemImage(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2963,39 +3468,12 @@ static PyObject *_wrap_wxTreeCtrl_GetItemSelectedImage(PyObject *self, PyObject return NULL; } } - _result = (int )wxTreeCtrl_GetItemSelectedImage(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); - return _resultobj; -} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxTreeCtrl_GetItemSelectedImage(_arg0,*_arg1); -#define wxTreeCtrl_GetItemData(_swigobj,_swigarg0) (_swigobj->GetItemData(_swigarg0)) -static PyObject *_wrap_wxTreeCtrl_GetItemData(PyObject *self, PyObject *args) { - PyObject * _resultobj; - wxTreeItemData * _result; - wxTreeCtrl * _arg0; - wxTreeItemId * _arg1; - char * _argc0 = 0; - char * _argc1 = 0; - char _ptemp[128]; - - self = self; - if(!PyArg_ParseTuple(args,"ss:wxTreeCtrl_GetItemData",&_argc0,&_argc1)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeCtrl_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCtrl_GetItemData. Expected _wxTreeCtrl_p."); - return NULL; - } - } - if (_argc1) { - if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxTreeItemId_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_GetItemData. Expected _wxTreeItemId_p."); - return NULL; - } - } - _result = (wxTreeItemData *)wxTreeCtrl_GetItemData(_arg0,*_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTreeItemData_p"); - _resultobj = Py_BuildValue("s",_ptemp); + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3029,10 +3507,14 @@ static PyObject *_wrap_wxTreeCtrl_SetItemText(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxTreeCtrl_SetItemText(_arg0,*_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetItemText(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -3065,8 +3547,12 @@ static PyObject *_wrap_wxTreeCtrl_SetItemImage(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_SetItemImage(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetItemImage(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3095,45 +3581,12 @@ static PyObject *_wrap_wxTreeCtrl_SetItemSelectedImage(PyObject *self, PyObject return NULL; } } - wxTreeCtrl_SetItemSelectedImage(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); - _resultobj = Py_None; - return _resultobj; -} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetItemSelectedImage(_arg0,*_arg1,_arg2); -#define wxTreeCtrl_SetItemData(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetItemData(_swigarg0,_swigarg1)) -static PyObject *_wrap_wxTreeCtrl_SetItemData(PyObject *self, PyObject *args) { - PyObject * _resultobj; - wxTreeCtrl * _arg0; - wxTreeItemId * _arg1; - wxTreeItemData * _arg2; - char * _argc0 = 0; - char * _argc1 = 0; - char * _argc2 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"sss:wxTreeCtrl_SetItemData",&_argc0,&_argc1,&_argc2)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeCtrl_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCtrl_SetItemData. Expected _wxTreeCtrl_p."); - return NULL; - } - } - if (_argc1) { - if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxTreeItemId_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_SetItemData. Expected _wxTreeItemId_p."); - return NULL; - } - } - if (_argc2) { - if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxTreeCtrl_SetItemData. Expected _wxTreeItemData_p."); - return NULL; - } - } - wxTreeCtrl_SetItemData(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3164,8 +3617,184 @@ static PyObject *_wrap_wxTreeCtrl_SetItemHasChildren(PyObject *self, PyObject *a } } _arg2 = (bool ) tempbool2; - wxTreeCtrl_SetItemHasChildren(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetItemHasChildren(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static wxPyTreeItemData * wxTreeCtrl_GetItemData(wxTreeCtrl *self,const wxTreeItemId & item) { + wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item); + if (data == NULL) { + data = new wxPyTreeItemData(); + self->SetItemData(item, data); + } + return data; + } +static PyObject *_wrap_wxTreeCtrl_GetItemData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPyTreeItemData * _result; + wxTreeCtrl * _arg0; + wxTreeItemId * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxTreeCtrl_GetItemData",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeCtrl_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCtrl_GetItemData. Expected _wxTreeCtrl_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxTreeItemId_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_GetItemData. Expected _wxTreeItemId_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPyTreeItemData *)wxTreeCtrl_GetItemData(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyTreeItemData_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static void wxTreeCtrl_SetItemData(wxTreeCtrl *self,const wxTreeItemId & item,wxPyTreeItemData * data) { + self->SetItemData(item, data); + } +static PyObject *_wrap_wxTreeCtrl_SetItemData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxTreeCtrl * _arg0; + wxTreeItemId * _arg1; + wxPyTreeItemData * _arg2; + char * _argc0 = 0; + char * _argc1 = 0; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sss:wxTreeCtrl_SetItemData",&_argc0,&_argc1,&_argc2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeCtrl_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCtrl_SetItemData. Expected _wxTreeCtrl_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxTreeItemId_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_SetItemData. Expected _wxTreeItemId_p."); + return NULL; + } + } + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxTreeCtrl_SetItemData. Expected _wxPyTreeItemData_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetItemData(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject * wxTreeCtrl_GetPyData(wxTreeCtrl *self,const wxTreeItemId & item) { + wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item); + if (data == NULL) { + data = new wxPyTreeItemData(); + self->SetItemData(item, data); + } + return data->GetData(); + } +static PyObject *_wrap_wxTreeCtrl_GetPyData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + PyObject * _result; + wxTreeCtrl * _arg0; + wxTreeItemId * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxTreeCtrl_GetPyData",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeCtrl_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCtrl_GetPyData. Expected _wxTreeCtrl_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxTreeItemId_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_GetPyData. Expected _wxTreeItemId_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxTreeCtrl_GetPyData(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = _result; +} + return _resultobj; +} + +static void wxTreeCtrl_SetPyData(wxTreeCtrl *self,const wxTreeItemId & item,PyObject * obj) { + wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item); + if (data == NULL) { + data = new wxPyTreeItemData(obj); + self->SetItemData(item, data); + } else + data->SetData(obj); + } +static PyObject *_wrap_wxTreeCtrl_SetPyData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxTreeCtrl * _arg0; + wxTreeItemId * _arg1; + PyObject * _arg2; + char * _argc0 = 0; + char * _argc1 = 0; + PyObject * _obj2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ssO:wxTreeCtrl_SetPyData",&_argc0,&_argc1,&_obj2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeCtrl_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCtrl_SetPyData. Expected _wxTreeCtrl_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxTreeItemId_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_SetPyData. Expected _wxTreeItemId_p."); + return NULL; + } + } +{ + _arg2 = _obj2; +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetPyData(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3194,8 +3823,12 @@ static PyObject *_wrap_wxTreeCtrl_IsVisible(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxTreeCtrl_IsVisible(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTreeCtrl_IsVisible(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3223,8 +3856,12 @@ static PyObject *_wrap_wxTreeCtrl_ItemHasChildren(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxTreeCtrl_ItemHasChildren(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTreeCtrl_ItemHasChildren(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3252,8 +3889,12 @@ static PyObject *_wrap_wxTreeCtrl_IsExpanded(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxTreeCtrl_IsExpanded(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTreeCtrl_IsExpanded(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3281,8 +3922,12 @@ static PyObject *_wrap_wxTreeCtrl_IsSelected(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxTreeCtrl_IsSelected(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTreeCtrl_IsSelected(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3303,8 +3948,12 @@ static PyObject *_wrap_wxTreeCtrl_GetRootItem(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetRootItem(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetRootItem(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3326,8 +3975,12 @@ static PyObject *_wrap_wxTreeCtrl_GetSelection(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetSelection(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetSelection(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3357,8 +4010,12 @@ static PyObject *_wrap_wxTreeCtrl_GetParent(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetParent(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetParent(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3395,8 +4052,12 @@ static PyObject *_wrap_wxTreeCtrl_GetFirstChild(PyObject *self, PyObject *args) temp = (long) PyInt_AsLong(_obj2); _arg2 = &temp; } - _result = new wxTreeItemId (wxTreeCtrl_GetFirstChild(_arg0,*_arg1,*_arg2)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetFirstChild(_arg0,*_arg1,*_arg2)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); { PyObject *o; @@ -3438,8 +4099,12 @@ static PyObject *_wrap_wxTreeCtrl_GetNextChild(PyObject *self, PyObject *args) { temp = (long) PyInt_AsLong(_obj2); _arg2 = &temp; } - _result = new wxTreeItemId (wxTreeCtrl_GetNextChild(_arg0,*_arg1,*_arg2)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetNextChild(_arg0,*_arg1,*_arg2)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); { PyObject *o; @@ -3474,8 +4139,12 @@ static PyObject *_wrap_wxTreeCtrl_GetNextSibling(PyObject *self, PyObject *args) return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetNextSibling(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetNextSibling(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3505,8 +4174,12 @@ static PyObject *_wrap_wxTreeCtrl_GetPrevSibling(PyObject *self, PyObject *args) return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetPrevSibling(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetPrevSibling(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3528,8 +4201,12 @@ static PyObject *_wrap_wxTreeCtrl_GetFirstVisibleItem(PyObject *self, PyObject * return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetFirstVisibleItem(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetFirstVisibleItem(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3559,8 +4236,12 @@ static PyObject *_wrap_wxTreeCtrl_GetNextVisible(PyObject *self, PyObject *args) return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetNextVisible(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetNextVisible(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3590,8 +4271,12 @@ static PyObject *_wrap_wxTreeCtrl_GetPrevVisible(PyObject *self, PyObject *args) return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_GetPrevVisible(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_GetPrevVisible(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3604,7 +4289,7 @@ static PyObject *_wrap_wxTreeCtrl_AddRoot(PyObject *self, PyObject *args) { wxString * _arg1; int _arg2 = -1; int _arg3 = -1; - wxTreeItemData * _arg4 = NULL; + wxPyTreeItemData * _arg4 = NULL; char * _argc0 = 0; PyObject * _obj1 = 0; char * _argc4 = 0; @@ -3624,16 +4309,20 @@ static PyObject *_wrap_wxTreeCtrl_AddRoot(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_argc4) { - if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxTreeCtrl_AddRoot. Expected _wxTreeItemData_p."); + if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxTreeCtrl_AddRoot. Expected _wxPyTreeItemData_p."); return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_AddRoot(_arg0,*_arg1,_arg2,_arg3,_arg4)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_AddRoot(_arg0,*_arg1,_arg2,_arg3,_arg4)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj1) @@ -3651,7 +4340,7 @@ static PyObject *_wrap_wxTreeCtrl_PrependItem(PyObject *self, PyObject *args) { wxString * _arg2; int _arg3 = -1; int _arg4 = -1; - wxTreeItemData * _arg5 = NULL; + wxPyTreeItemData * _arg5 = NULL; char * _argc0 = 0; char * _argc1 = 0; PyObject * _obj2 = 0; @@ -3678,16 +4367,20 @@ static PyObject *_wrap_wxTreeCtrl_PrependItem(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc5) { - if (SWIG_GetPtr(_argc5,(void **) &_arg5,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of wxTreeCtrl_PrependItem. Expected _wxTreeItemData_p."); + if (SWIG_GetPtr(_argc5,(void **) &_arg5,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of wxTreeCtrl_PrependItem. Expected _wxPyTreeItemData_p."); return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_PrependItem(_arg0,*_arg1,*_arg2,_arg3,_arg4,_arg5)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_PrependItem(_arg0,*_arg1,*_arg2,_arg3,_arg4,_arg5)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -3706,7 +4399,7 @@ static PyObject *_wrap_wxTreeCtrl_InsertItem(PyObject *self, PyObject *args) { wxString * _arg3; int _arg4 = -1; int _arg5 = -1; - wxTreeItemData * _arg6 = NULL; + wxPyTreeItemData * _arg6 = NULL; char * _argc0 = 0; char * _argc1 = 0; char * _argc2 = 0; @@ -3740,16 +4433,20 @@ static PyObject *_wrap_wxTreeCtrl_InsertItem(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg3 = new wxString(PyString_AsString(_obj3)); + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); } if (_argc6) { - if (SWIG_GetPtr(_argc6,(void **) &_arg6,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of wxTreeCtrl_InsertItem. Expected _wxTreeItemData_p."); + if (SWIG_GetPtr(_argc6,(void **) &_arg6,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of wxTreeCtrl_InsertItem. Expected _wxPyTreeItemData_p."); return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_InsertItem(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_InsertItem(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj3) @@ -3767,7 +4464,7 @@ static PyObject *_wrap_wxTreeCtrl_AppendItem(PyObject *self, PyObject *args) { wxString * _arg2; int _arg3 = -1; int _arg4 = -1; - wxTreeItemData * _arg5 = NULL; + wxPyTreeItemData * _arg5 = NULL; char * _argc0 = 0; char * _argc1 = 0; PyObject * _obj2 = 0; @@ -3794,16 +4491,20 @@ static PyObject *_wrap_wxTreeCtrl_AppendItem(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc5) { - if (SWIG_GetPtr(_argc5,(void **) &_arg5,"_wxTreeItemData_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of wxTreeCtrl_AppendItem. Expected _wxTreeItemData_p."); + if (SWIG_GetPtr(_argc5,(void **) &_arg5,"_wxPyTreeItemData_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of wxTreeCtrl_AppendItem. Expected _wxPyTreeItemData_p."); return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_AppendItem(_arg0,*_arg1,*_arg2,_arg3,_arg4,_arg5)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_AppendItem(_arg0,*_arg1,*_arg2,_arg3,_arg4,_arg5)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -3835,8 +4536,12 @@ static PyObject *_wrap_wxTreeCtrl_Delete(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_Delete(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_Delete(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3864,8 +4569,12 @@ static PyObject *_wrap_wxTreeCtrl_DeleteChildren(PyObject *self, PyObject *args) return NULL; } } - wxTreeCtrl_DeleteChildren(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_DeleteChildren(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3885,8 +4594,12 @@ static PyObject *_wrap_wxTreeCtrl_DeleteAllItems(PyObject *self, PyObject *args) return NULL; } } - wxTreeCtrl_DeleteAllItems(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_DeleteAllItems(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3914,8 +4627,12 @@ static PyObject *_wrap_wxTreeCtrl_Expand(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_Expand(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_Expand(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3943,8 +4660,12 @@ static PyObject *_wrap_wxTreeCtrl_Collapse(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_Collapse(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_Collapse(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3972,8 +4693,12 @@ static PyObject *_wrap_wxTreeCtrl_CollapseAndReset(PyObject *self, PyObject *arg return NULL; } } - wxTreeCtrl_CollapseAndReset(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_CollapseAndReset(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4001,8 +4726,12 @@ static PyObject *_wrap_wxTreeCtrl_Toggle(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_Toggle(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_Toggle(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4022,8 +4751,12 @@ static PyObject *_wrap_wxTreeCtrl_Unselect(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_Unselect(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_Unselect(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4051,8 +4784,12 @@ static PyObject *_wrap_wxTreeCtrl_SelectItem(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_SelectItem(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SelectItem(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4080,8 +4817,12 @@ static PyObject *_wrap_wxTreeCtrl_EnsureVisible(PyObject *self, PyObject *args) return NULL; } } - wxTreeCtrl_EnsureVisible(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_EnsureVisible(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4109,8 +4850,12 @@ static PyObject *_wrap_wxTreeCtrl_ScrollTo(PyObject *self, PyObject *args) { return NULL; } } - wxTreeCtrl_ScrollTo(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_ScrollTo(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4140,8 +4885,12 @@ static PyObject *_wrap_wxTreeCtrl_EditLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxTextCtrl *)wxTreeCtrl_EditLabel(_arg0,*_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTextCtrl *)wxTreeCtrl_EditLabel(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4163,8 +4912,12 @@ static PyObject *_wrap_wxTreeCtrl_GetEditControl(PyObject *self, PyObject *args) return NULL; } } - _result = (wxTextCtrl *)wxTreeCtrl_GetEditControl(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTextCtrl *)wxTreeCtrl_GetEditControl(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4195,8 +4948,12 @@ static PyObject *_wrap_wxTreeCtrl_EndEditLabel(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxTreeCtrl_EndEditLabel(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_EndEditLabel(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4227,8 +4984,12 @@ static PyObject *_wrap_wxTreeCtrl_SetItemBold(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxTreeCtrl_SetItemBold(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxTreeCtrl_SetItemBold(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4257,8 +5018,12 @@ static PyObject *_wrap_wxTreeCtrl_IsBold(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxTreeCtrl_IsBold(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTreeCtrl_IsBold(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4287,8 +5052,12 @@ static PyObject *_wrap_wxTreeCtrl_HitTest(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxTreeItemId (wxTreeCtrl_HitTest(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxTreeItemId (wxTreeCtrl_HitTest(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxTreeItemId_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4329,12 +5098,14 @@ static PyMethodDef controls2cMethods[] = { { "wxTreeCtrl_IsExpanded", _wrap_wxTreeCtrl_IsExpanded, 1 }, { "wxTreeCtrl_ItemHasChildren", _wrap_wxTreeCtrl_ItemHasChildren, 1 }, { "wxTreeCtrl_IsVisible", _wrap_wxTreeCtrl_IsVisible, 1 }, - { "wxTreeCtrl_SetItemHasChildren", _wrap_wxTreeCtrl_SetItemHasChildren, 1 }, + { "wxTreeCtrl_SetPyData", _wrap_wxTreeCtrl_SetPyData, 1 }, + { "wxTreeCtrl_GetPyData", _wrap_wxTreeCtrl_GetPyData, 1 }, { "wxTreeCtrl_SetItemData", _wrap_wxTreeCtrl_SetItemData, 1 }, + { "wxTreeCtrl_GetItemData", _wrap_wxTreeCtrl_GetItemData, 1 }, + { "wxTreeCtrl_SetItemHasChildren", _wrap_wxTreeCtrl_SetItemHasChildren, 1 }, { "wxTreeCtrl_SetItemSelectedImage", _wrap_wxTreeCtrl_SetItemSelectedImage, 1 }, { "wxTreeCtrl_SetItemImage", _wrap_wxTreeCtrl_SetItemImage, 1 }, { "wxTreeCtrl_SetItemText", _wrap_wxTreeCtrl_SetItemText, 1 }, - { "wxTreeCtrl_GetItemData", _wrap_wxTreeCtrl_GetItemData, 1 }, { "wxTreeCtrl_GetItemSelectedImage", _wrap_wxTreeCtrl_GetItemSelectedImage, 1 }, { "wxTreeCtrl_GetItemImage", _wrap_wxTreeCtrl_GetItemImage, 1 }, { "wxTreeCtrl_GetItemText", _wrap_wxTreeCtrl_GetItemText, 1 }, @@ -4353,7 +5124,8 @@ static PyMethodDef controls2cMethods[] = { { "wxTreeEvent_GetItem", _wrap_wxTreeEvent_GetItem, 1 }, { "wxTreeItemData_SetId", _wrap_wxTreeItemData_SetId, 1 }, { "wxTreeItemData_GetId", _wrap_wxTreeItemData_GetId, 1 }, - { "delete_wxTreeItemData", _wrap_delete_wxTreeItemData, 1 }, + { "wxTreeItemData_SetData", _wrap_wxTreeItemData_SetData, 1 }, + { "wxTreeItemData_GetData", _wrap_wxTreeItemData_GetData, 1 }, { "new_wxTreeItemData", _wrap_new_wxTreeItemData, 1 }, { "wxTreeItemId_IsOk", _wrap_wxTreeItemId_IsOk, 1 }, { "delete_wxTreeItemId", _wrap_delete_wxTreeItemId, 1 }, @@ -4514,6 +5286,7 @@ SWIGEXPORT(void,initcontrols2c)() { SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0); SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0); SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0); + SWIG_RegisterMapping("_class_wxPyTreeItemData","_wxPyTreeItemData",0); SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxTreeCtrl",SwigwxTreeCtrlTowxEvtHandler); SWIG_RegisterMapping("_class_wxEvtHandler","_wxTreeCtrl",SwigwxTreeCtrlTowxEvtHandler); SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxListCtrl",SwigwxListCtrlTowxEvtHandler); @@ -4551,6 +5324,7 @@ SWIGEXPORT(void,initcontrols2c)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); @@ -4580,13 +5354,13 @@ SWIGEXPORT(void,initcontrols2c)() { SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0); SWIG_RegisterMapping("_class_wxButton","_wxButton",0); SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0); - SWIG_RegisterMapping("_wxTreeItemData","_class_wxTreeItemData",0); SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0); SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0); SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0); SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0); SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_wxListItem","_class_wxListItem",0); @@ -4699,6 +5473,7 @@ SWIGEXPORT(void,initcontrols2c)() { SWIG_RegisterMapping("_wxSize","_class_wxSize",0); SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0); SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",0); + SWIG_RegisterMapping("_wxPyTreeItemData","_class_wxPyTreeItemData",0); SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0); SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0); SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0); @@ -4734,7 +5509,6 @@ SWIGEXPORT(void,initcontrols2c)() { SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0); SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0); SWIG_RegisterMapping("_class_wxListCtrl","_wxListCtrl",0); - SWIG_RegisterMapping("_class_wxTreeItemData","_wxTreeItemData",0); SWIG_RegisterMapping("_class_wxSize","_wxSize",0); SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0); SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0); diff --git a/utils/wxPython/src/msw/controls2.py b/utils/wxPython/src/msw/controls2.py index d8fea80238..d0c4d448b3 100644 --- a/utils/wxPython/src/msw/controls2.py +++ b/utils/wxPython/src/msw/controls2.py @@ -343,9 +343,12 @@ class wxTreeItemDataPtr : def __init__(self,this): self.this = this self.thisown = 0 - def __del__(self): - if self.thisown == 1 : - controls2c.delete_wxTreeItemData(self.this) + def GetData(self): + val = controls2c.wxTreeItemData_GetData(self.this) + return val + def SetData(self,arg0): + val = controls2c.wxTreeItemData_SetData(self.this,arg0) + return val def GetId(self): val = controls2c.wxTreeItemData_GetId(self.this) val = wxTreeItemIdPtr(val) @@ -356,8 +359,8 @@ class wxTreeItemDataPtr : def __repr__(self): return "" class wxTreeItemData(wxTreeItemDataPtr): - def __init__(self) : - self.this = controls2c.new_wxTreeItemData() + def __init__(self,*args) : + self.this = apply(controls2c.new_wxTreeItemData,()+args) self.thisown = 1 @@ -433,10 +436,6 @@ class wxTreeCtrlPtr(wxControlPtr): def GetItemSelectedImage(self,arg0): val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this) return val - def GetItemData(self,arg0): - val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this) - val = wxTreeItemDataPtr(val) - return val def SetItemText(self,arg0,arg1): val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1) return val @@ -446,11 +445,21 @@ class wxTreeCtrlPtr(wxControlPtr): def SetItemSelectedImage(self,arg0,arg1): val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1) return val + def SetItemHasChildren(self,arg0,*args): + val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args) + return val + def GetItemData(self,arg0): + val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this) + val = wxTreeItemDataPtr(val) + return val def SetItemData(self,arg0,arg1): val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this) return val - def SetItemHasChildren(self,arg0,*args): - val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args) + def GetPyData(self,arg0): + val = controls2c.wxTreeCtrl_GetPyData(self.this,arg0.this) + return val + def SetPyData(self,arg0,arg1): + val = controls2c.wxTreeCtrl_SetPyData(self.this,arg0.this,arg1) return val def IsVisible(self,arg0): val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this) diff --git a/utils/wxPython/src/msw/events.cpp b/utils/wxPython/src/msw/events.cpp index cd4504a43f..328ab2e09c 100644 --- a/utils/wxPython/src/msw/events.cpp +++ b/utils/wxPython/src/msw/events.cpp @@ -131,8 +131,12 @@ static PyObject *_wrap_wxEvent_GetEventObject(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxObject *)wxEvent_GetEventObject(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxObject_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxObject *)wxEvent_GetEventObject(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxObject_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -153,8 +157,12 @@ static PyObject *_wrap_wxEvent_GetEventType(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxEventType )wxEvent_GetEventType(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxEventType )wxEvent_GetEventType(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -174,8 +182,12 @@ static PyObject *_wrap_wxEvent_GetId(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxEvent_GetId(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxEvent_GetId(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -195,8 +207,12 @@ static PyObject *_wrap_wxEvent_GetSkipped(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxEvent_GetSkipped(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxEvent_GetSkipped(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -216,8 +232,12 @@ static PyObject *_wrap_wxEvent_GetTimestamp(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxEvent_GetTimestamp(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxEvent_GetTimestamp(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -244,8 +264,12 @@ static PyObject *_wrap_wxEvent_SetEventObject(PyObject *self, PyObject *args) { return NULL; } } - wxEvent_SetEventObject(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEvent_SetEventObject(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -266,8 +290,12 @@ static PyObject *_wrap_wxEvent_SetEventType(PyObject *self, PyObject *args) { return NULL; } } - wxEvent_SetEventType(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEvent_SetEventType(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -288,8 +316,12 @@ static PyObject *_wrap_wxEvent_SetId(PyObject *self, PyObject *args) { return NULL; } } - wxEvent_SetId(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEvent_SetId(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -310,8 +342,12 @@ static PyObject *_wrap_wxEvent_SetTimestamp(PyObject *self, PyObject *args) { return NULL; } } - wxEvent_SetTimestamp(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEvent_SetTimestamp(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -334,8 +370,12 @@ static PyObject *_wrap_wxEvent_Skip(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxEvent_Skip(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEvent_Skip(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -365,8 +405,12 @@ static PyObject *_wrap_wxSizeEvent_GetSize(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxSize (wxSizeEvent_GetSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxSizeEvent_GetSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -397,8 +441,12 @@ static PyObject *_wrap_wxCloseEvent_SetLoggingOff(PyObject *self, PyObject *args } } _arg1 = (bool ) tempbool1; - wxCloseEvent_SetLoggingOff(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxCloseEvent_SetLoggingOff(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -419,8 +467,12 @@ static PyObject *_wrap_wxCloseEvent_GetLoggingOff(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxCloseEvent_GetLoggingOff(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxCloseEvent_GetLoggingOff(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -442,8 +494,12 @@ static PyObject *_wrap_wxCloseEvent_Veto(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxCloseEvent_Veto(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxCloseEvent_Veto(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -464,8 +520,12 @@ static PyObject *_wrap_wxCloseEvent_CanVeto(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxCloseEvent_CanVeto(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxCloseEvent_CanVeto(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -485,8 +545,12 @@ static PyObject *_wrap_wxCloseEvent_GetVeto(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxCloseEvent_GetVeto(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxCloseEvent_GetVeto(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -508,8 +572,12 @@ static PyObject *_wrap_wxCloseEvent_SetCanVeto(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxCloseEvent_SetCanVeto(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxCloseEvent_SetCanVeto(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -538,8 +606,12 @@ static PyObject *_wrap_wxCommandEvent_Checked(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxCommandEvent_Checked(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxCommandEvent_Checked(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -559,8 +631,12 @@ static PyObject *_wrap_wxCommandEvent_GetExtraLong(PyObject *self, PyObject *arg return NULL; } } - _result = (long )wxCommandEvent_GetExtraLong(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxCommandEvent_GetExtraLong(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -580,8 +656,12 @@ static PyObject *_wrap_wxCommandEvent_GetInt(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxCommandEvent_GetInt(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxCommandEvent_GetInt(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -601,15 +681,19 @@ static PyObject *_wrap_wxCommandEvent_GetSelection(PyObject *self, PyObject *arg return NULL; } } - _result = (int )wxCommandEvent_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxCommandEvent_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } #define wxCommandEvent_GetString(_swigobj) (_swigobj->GetString()) static PyObject *_wrap_wxCommandEvent_GetString(PyObject *self, PyObject *args) { PyObject * _resultobj; - char * _result; + wxString * _result; wxCommandEvent * _arg0; char * _argc0 = 0; @@ -622,8 +706,17 @@ static PyObject *_wrap_wxCommandEvent_GetString(PyObject *self, PyObject *args) return NULL; } } - _result = (char *)wxCommandEvent_GetString(_arg0); - _resultobj = Py_BuildValue("s", _result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxCommandEvent_GetString(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); +} +{ + delete _result; +} return _resultobj; } @@ -643,8 +736,12 @@ static PyObject *_wrap_wxCommandEvent_IsSelection(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxCommandEvent_IsSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxCommandEvent_IsSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -680,8 +777,12 @@ static PyObject *_wrap_wxScrollEvent_GetOrientation(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxScrollEvent_GetOrientation(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxScrollEvent_GetOrientation(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -701,8 +802,12 @@ static PyObject *_wrap_wxScrollEvent_GetPosition(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxScrollEvent_GetPosition(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxScrollEvent_GetPosition(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -754,8 +859,12 @@ static PyObject *_wrap_wxMouseEvent_IsButton(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_IsButton(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_IsButton(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -776,8 +885,12 @@ static PyObject *_wrap_wxMouseEvent_ButtonDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_ButtonDown(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_ButtonDown(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -798,8 +911,12 @@ static PyObject *_wrap_wxMouseEvent_ButtonDClick(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxMouseEvent_ButtonDClick(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_ButtonDClick(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -820,8 +937,12 @@ static PyObject *_wrap_wxMouseEvent_ButtonUp(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_ButtonUp(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_ButtonUp(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -842,8 +963,12 @@ static PyObject *_wrap_wxMouseEvent_Button(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_Button(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_Button(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -864,8 +989,12 @@ static PyObject *_wrap_wxMouseEvent_ButtonIsDown(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxMouseEvent_ButtonIsDown(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_ButtonIsDown(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -885,8 +1014,12 @@ static PyObject *_wrap_wxMouseEvent_ControlDown(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxMouseEvent_ControlDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_ControlDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -906,8 +1039,12 @@ static PyObject *_wrap_wxMouseEvent_MetaDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_MetaDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_MetaDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -927,8 +1064,12 @@ static PyObject *_wrap_wxMouseEvent_AltDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_AltDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_AltDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -948,8 +1089,12 @@ static PyObject *_wrap_wxMouseEvent_ShiftDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_ShiftDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_ShiftDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -969,8 +1114,12 @@ static PyObject *_wrap_wxMouseEvent_LeftDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_LeftDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_LeftDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -990,8 +1139,12 @@ static PyObject *_wrap_wxMouseEvent_MiddleDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_MiddleDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_MiddleDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1011,8 +1164,12 @@ static PyObject *_wrap_wxMouseEvent_RightDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_RightDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_RightDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1032,8 +1189,12 @@ static PyObject *_wrap_wxMouseEvent_LeftUp(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_LeftUp(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_LeftUp(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1053,8 +1214,12 @@ static PyObject *_wrap_wxMouseEvent_MiddleUp(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_MiddleUp(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_MiddleUp(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1074,8 +1239,12 @@ static PyObject *_wrap_wxMouseEvent_RightUp(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_RightUp(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_RightUp(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1095,8 +1264,12 @@ static PyObject *_wrap_wxMouseEvent_LeftDClick(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_LeftDClick(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_LeftDClick(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1116,8 +1289,12 @@ static PyObject *_wrap_wxMouseEvent_MiddleDClick(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxMouseEvent_MiddleDClick(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_MiddleDClick(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1137,8 +1314,12 @@ static PyObject *_wrap_wxMouseEvent_RightDClick(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxMouseEvent_RightDClick(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_RightDClick(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1158,8 +1339,12 @@ static PyObject *_wrap_wxMouseEvent_LeftIsDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_LeftIsDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_LeftIsDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1179,8 +1364,12 @@ static PyObject *_wrap_wxMouseEvent_MiddleIsDown(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxMouseEvent_MiddleIsDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_MiddleIsDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1200,8 +1389,12 @@ static PyObject *_wrap_wxMouseEvent_RightIsDown(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxMouseEvent_RightIsDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_RightIsDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1221,8 +1414,12 @@ static PyObject *_wrap_wxMouseEvent_Dragging(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_Dragging(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_Dragging(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1242,8 +1439,12 @@ static PyObject *_wrap_wxMouseEvent_Moving(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_Moving(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_Moving(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1263,8 +1464,12 @@ static PyObject *_wrap_wxMouseEvent_Entering(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_Entering(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_Entering(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1284,8 +1489,12 @@ static PyObject *_wrap_wxMouseEvent_Leaving(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMouseEvent_Leaving(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMouseEvent_Leaving(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1314,8 +1523,12 @@ static PyObject *_wrap_wxMouseEvent_Position(PyObject *self, PyObject *args) { return NULL; } } - wxMouseEvent_Position(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMouseEvent_Position(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -1347,8 +1560,12 @@ static PyObject *_wrap_wxMouseEvent_GetPosition(PyObject *self, PyObject *args) return NULL; } } - _result = new wxPoint (wxMouseEvent_GetPosition(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxMouseEvent_GetPosition(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1378,8 +1595,12 @@ static PyObject *_wrap_wxMouseEvent_GetLogicalPosition(PyObject *self, PyObject return NULL; } } - _result = new wxPoint (wxMouseEvent_GetLogicalPosition(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxMouseEvent_GetLogicalPosition(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1400,8 +1621,12 @@ static PyObject *_wrap_wxMouseEvent_GetX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxMouseEvent_GetX(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxMouseEvent_GetX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1421,8 +1646,12 @@ static PyObject *_wrap_wxMouseEvent_GetY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxMouseEvent_GetY(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxMouseEvent_GetY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1450,8 +1679,12 @@ static PyObject *_wrap_wxKeyEvent_ControlDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxKeyEvent_ControlDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxKeyEvent_ControlDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1471,8 +1704,12 @@ static PyObject *_wrap_wxKeyEvent_MetaDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxKeyEvent_MetaDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxKeyEvent_MetaDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1492,8 +1729,12 @@ static PyObject *_wrap_wxKeyEvent_AltDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxKeyEvent_AltDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxKeyEvent_AltDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1513,8 +1754,12 @@ static PyObject *_wrap_wxKeyEvent_ShiftDown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxKeyEvent_ShiftDown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxKeyEvent_ShiftDown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1534,8 +1779,12 @@ static PyObject *_wrap_wxKeyEvent_KeyCode(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxKeyEvent_KeyCode(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxKeyEvent_KeyCode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1564,8 +1813,12 @@ static PyObject *_wrap_wxMoveEvent_GetPosition(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxPoint (wxMoveEvent_GetPosition(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxMoveEvent_GetPosition(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1603,8 +1856,12 @@ static PyObject *_wrap_wxEraseEvent_GetDC(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxDC *)wxEraseEvent_GetDC(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxDC *)wxEraseEvent_GetDC(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1641,8 +1898,12 @@ static PyObject *_wrap_wxActivateEvent_GetActive(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxActivateEvent_GetActive(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxActivateEvent_GetActive(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1678,8 +1939,12 @@ static PyObject *_wrap_wxMenuEvent_GetMenuId(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxMenuEvent_GetMenuId(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMenuEvent_GetMenuId(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1709,8 +1974,12 @@ static PyObject *_wrap_wxShowEvent_SetShow(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxShowEvent_SetShow(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxShowEvent_SetShow(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1731,8 +2000,12 @@ static PyObject *_wrap_wxShowEvent_GetShow(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxShowEvent_GetShow(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxShowEvent_GetShow(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1777,8 +2050,12 @@ static PyObject *_wrap_wxJoystickEvent_GetPosition(PyObject *self, PyObject *arg return NULL; } } - _result = new wxPoint (wxJoystickEvent_GetPosition(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxJoystickEvent_GetPosition(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1799,8 +2076,12 @@ static PyObject *_wrap_wxJoystickEvent_GetZPosition(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxJoystickEvent_GetZPosition(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxJoystickEvent_GetZPosition(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1820,8 +2101,12 @@ static PyObject *_wrap_wxJoystickEvent_GetButtonState(PyObject *self, PyObject * return NULL; } } - _result = (int )wxJoystickEvent_GetButtonState(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxJoystickEvent_GetButtonState(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1841,8 +2126,12 @@ static PyObject *_wrap_wxJoystickEvent_GetButtonChange(PyObject *self, PyObject return NULL; } } - _result = (int )wxJoystickEvent_GetButtonChange(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxJoystickEvent_GetButtonChange(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1862,8 +2151,12 @@ static PyObject *_wrap_wxJoystickEvent_GetJoystick(PyObject *self, PyObject *arg return NULL; } } - _result = (int )wxJoystickEvent_GetJoystick(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxJoystickEvent_GetJoystick(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1883,8 +2176,12 @@ static PyObject *_wrap_wxJoystickEvent_SetJoystick(PyObject *self, PyObject *arg return NULL; } } - wxJoystickEvent_SetJoystick(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxJoystickEvent_SetJoystick(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1905,8 +2202,12 @@ static PyObject *_wrap_wxJoystickEvent_SetButtonState(PyObject *self, PyObject * return NULL; } } - wxJoystickEvent_SetButtonState(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxJoystickEvent_SetButtonState(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1927,8 +2228,12 @@ static PyObject *_wrap_wxJoystickEvent_SetButtonChange(PyObject *self, PyObject return NULL; } } - wxJoystickEvent_SetButtonChange(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxJoystickEvent_SetButtonChange(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1956,8 +2261,12 @@ static PyObject *_wrap_wxJoystickEvent_SetPosition(PyObject *self, PyObject *arg return NULL; } } - wxJoystickEvent_SetPosition(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxJoystickEvent_SetPosition(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1978,8 +2287,12 @@ static PyObject *_wrap_wxJoystickEvent_SetZPosition(PyObject *self, PyObject *ar return NULL; } } - wxJoystickEvent_SetZPosition(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxJoystickEvent_SetZPosition(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2000,8 +2313,12 @@ static PyObject *_wrap_wxJoystickEvent_IsButton(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxJoystickEvent_IsButton(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxJoystickEvent_IsButton(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2021,8 +2338,12 @@ static PyObject *_wrap_wxJoystickEvent_IsMove(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxJoystickEvent_IsMove(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxJoystickEvent_IsMove(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2042,8 +2363,12 @@ static PyObject *_wrap_wxJoystickEvent_IsZMove(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxJoystickEvent_IsZMove(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxJoystickEvent_IsZMove(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2064,8 +2389,12 @@ static PyObject *_wrap_wxJoystickEvent_ButtonDown(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxJoystickEvent_ButtonDown(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxJoystickEvent_ButtonDown(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2086,8 +2415,12 @@ static PyObject *_wrap_wxJoystickEvent_ButtonUp(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxJoystickEvent_ButtonUp(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxJoystickEvent_ButtonUp(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2108,8 +2441,12 @@ static PyObject *_wrap_wxJoystickEvent_ButtonIsDown(PyObject *self, PyObject *ar return NULL; } } - _result = (bool )wxJoystickEvent_ButtonIsDown(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxJoystickEvent_ButtonIsDown(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2138,8 +2475,12 @@ static PyObject *_wrap_wxDropFilesEvent_GetPosition(PyObject *self, PyObject *ar return NULL; } } - _result = new wxPoint (wxDropFilesEvent_GetPosition(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxDropFilesEvent_GetPosition(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2160,8 +2501,12 @@ static PyObject *_wrap_wxDropFilesEvent_GetNumberOfFiles(PyObject *self, PyObjec return NULL; } } - _result = (int )wxDropFilesEvent_GetNumberOfFiles(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxDropFilesEvent_GetNumberOfFiles(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2195,8 +2540,12 @@ static PyObject *_wrap_wxDropFilesEvent_GetFiles(PyObject *self, PyObject *args) return NULL; } } - _result = (PyObject *)wxDropFilesEvent_GetFiles(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxDropFilesEvent_GetFiles(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -2228,8 +2577,12 @@ static PyObject *_wrap_wxIdleEvent_RequestMore(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxIdleEvent_RequestMore(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIdleEvent_RequestMore(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2250,8 +2603,12 @@ static PyObject *_wrap_wxIdleEvent_MoreRequested(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxIdleEvent_MoreRequested(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxIdleEvent_MoreRequested(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2279,8 +2636,12 @@ static PyObject *_wrap_wxUpdateUIEvent_GetChecked(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxUpdateUIEvent_GetChecked(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxUpdateUIEvent_GetChecked(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2300,8 +2661,12 @@ static PyObject *_wrap_wxUpdateUIEvent_GetEnabled(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxUpdateUIEvent_GetEnabled(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxUpdateUIEvent_GetEnabled(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2321,8 +2686,12 @@ static PyObject *_wrap_wxUpdateUIEvent_GetText(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxUpdateUIEvent_GetText(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxUpdateUIEvent_GetText(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -2347,8 +2716,12 @@ static PyObject *_wrap_wxUpdateUIEvent_GetSetText(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxUpdateUIEvent_GetSetText(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxUpdateUIEvent_GetSetText(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2368,8 +2741,12 @@ static PyObject *_wrap_wxUpdateUIEvent_GetSetChecked(PyObject *self, PyObject *a return NULL; } } - _result = (bool )wxUpdateUIEvent_GetSetChecked(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxUpdateUIEvent_GetSetChecked(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2389,8 +2766,12 @@ static PyObject *_wrap_wxUpdateUIEvent_GetSetEnabled(PyObject *self, PyObject *a return NULL; } } - _result = (bool )wxUpdateUIEvent_GetSetEnabled(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxUpdateUIEvent_GetSetEnabled(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2412,8 +2793,12 @@ static PyObject *_wrap_wxUpdateUIEvent_Check(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxUpdateUIEvent_Check(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxUpdateUIEvent_Check(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2436,8 +2821,12 @@ static PyObject *_wrap_wxUpdateUIEvent_Enable(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxUpdateUIEvent_Enable(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxUpdateUIEvent_Enable(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2464,10 +2853,14 @@ static PyObject *_wrap_wxUpdateUIEvent_SetText(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxUpdateUIEvent_SetText(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxUpdateUIEvent_SetText(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -2484,7 +2877,135 @@ static void *SwigwxSysColourChangedEventTowxEvent(void *ptr) { return (void *) dest; } +static void *SwigwxPyEventTowxCommandEvent(void *ptr) { + wxPyEvent *src; + wxCommandEvent *dest; + src = (wxPyEvent *) ptr; + dest = (wxCommandEvent *) src; + return (void *) dest; +} + +static void *SwigwxPyEventTowxEvent(void *ptr) { + wxPyEvent *src; + wxEvent *dest; + src = (wxPyEvent *) ptr; + dest = (wxEvent *) src; + return (void *) dest; +} + +#define new_wxPyEvent(_swigarg0,_swigarg1) (new wxPyEvent(_swigarg0,_swigarg1)) +static PyObject *_wrap_new_wxPyEvent(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPyEvent * _result; + wxEventType _arg0 = (wxEVT_NULL); + PyObject * _arg1 = Py_None; + PyObject * _obj1 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"|iO:new_wxPyEvent",&_arg0,&_obj1)) + return NULL; + if (_obj1) +{ + _arg1 = _obj1; +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPyEvent *)new_wxPyEvent(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyEvent_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define delete_wxPyEvent(_swigobj) (delete _swigobj) +static PyObject *_wrap_delete_wxPyEvent(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPyEvent * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:delete_wxPyEvent",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPyEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxPyEvent. Expected _wxPyEvent_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxPyEvent(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxPyEvent_SetUserData(_swigobj,_swigarg0) (_swigobj->SetUserData(_swigarg0)) +static PyObject *_wrap_wxPyEvent_SetUserData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPyEvent * _arg0; + PyObject * _arg1; + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sO:wxPyEvent_SetUserData",&_argc0,&_obj1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPyEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyEvent_SetUserData. Expected _wxPyEvent_p."); + return NULL; + } + } +{ + _arg1 = _obj1; +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyEvent_SetUserData(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxPyEvent_GetUserData(_swigobj) (_swigobj->GetUserData()) +static PyObject *_wrap_wxPyEvent_GetUserData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + PyObject * _result; + wxPyEvent * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxPyEvent_GetUserData",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPyEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyEvent_GetUserData. Expected _wxPyEvent_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxPyEvent_GetUserData(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = _result; +} + return _resultobj; +} + static PyMethodDef eventscMethods[] = { + { "wxPyEvent_GetUserData", _wrap_wxPyEvent_GetUserData, 1 }, + { "wxPyEvent_SetUserData", _wrap_wxPyEvent_SetUserData, 1 }, + { "delete_wxPyEvent", _wrap_delete_wxPyEvent, 1 }, + { "new_wxPyEvent", _wrap_new_wxPyEvent, 1 }, { "wxUpdateUIEvent_SetText", _wrap_wxUpdateUIEvent_SetText, 1 }, { "wxUpdateUIEvent_Enable", _wrap_wxUpdateUIEvent_Enable, 1 }, { "wxUpdateUIEvent_Check", _wrap_wxUpdateUIEvent_Check, 1 }, @@ -2598,6 +3119,8 @@ SWIGEXPORT(void,initeventsc)() { * (Used by the SWIG pointer type-checker). */ SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0); + SWIG_RegisterMapping("_wxEvent","_class_wxPyEvent",SwigwxPyEventTowxEvent); + SWIG_RegisterMapping("_wxEvent","_wxPyEvent",SwigwxPyEventTowxEvent); SWIG_RegisterMapping("_wxEvent","_class_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent); SWIG_RegisterMapping("_wxEvent","_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent); SWIG_RegisterMapping("_wxEvent","_class_wxUpdateUIEvent",SwigwxUpdateUIEventTowxEvent); @@ -2661,6 +3184,7 @@ SWIGEXPORT(void,initeventsc)() { SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0); SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0); SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0); @@ -2669,6 +3193,8 @@ SWIGEXPORT(void,initeventsc)() { SWIG_RegisterMapping("_uint","_unsigned_int",0); SWIG_RegisterMapping("_uint","_int",0); SWIG_RegisterMapping("_uint","_wxWindowID",0); + SWIG_RegisterMapping("_class_wxEvent","_class_wxPyEvent",SwigwxPyEventTowxEvent); + SWIG_RegisterMapping("_class_wxEvent","_wxPyEvent",SwigwxPyEventTowxEvent); SWIG_RegisterMapping("_class_wxEvent","_class_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent); SWIG_RegisterMapping("_class_wxEvent","_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent); SWIG_RegisterMapping("_class_wxEvent","_class_wxUpdateUIEvent",SwigwxUpdateUIEventTowxEvent); @@ -2715,6 +3241,8 @@ SWIGEXPORT(void,initeventsc)() { SWIG_RegisterMapping("_class_wxEvent","_wxSizeEvent",SwigwxSizeEventTowxEvent); SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0); SWIG_RegisterMapping("_wxRect","_class_wxRect",0); + SWIG_RegisterMapping("_wxCommandEvent","_class_wxPyEvent",SwigwxPyEventTowxCommandEvent); + SWIG_RegisterMapping("_wxCommandEvent","_wxPyEvent",SwigwxPyEventTowxCommandEvent); SWIG_RegisterMapping("_wxCommandEvent","_class_wxSpinEvent",SwigwxSpinEventTowxCommandEvent); SWIG_RegisterMapping("_wxCommandEvent","_wxSpinEvent",SwigwxSpinEventTowxCommandEvent); SWIG_RegisterMapping("_wxCommandEvent","_class_wxScrollEvent",SwigwxScrollEventTowxCommandEvent); @@ -2724,6 +3252,7 @@ SWIGEXPORT(void,initeventsc)() { SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0); SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_wxScrollEvent","_class_wxSpinEvent",SwigwxSpinEventTowxScrollEvent); SWIG_RegisterMapping("_wxScrollEvent","_wxSpinEvent",SwigwxSpinEventTowxScrollEvent); @@ -2795,6 +3324,8 @@ SWIGEXPORT(void,initeventsc)() { SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0); SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0); SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0); + SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxPyEvent",SwigwxPyEventTowxCommandEvent); + SWIG_RegisterMapping("_class_wxCommandEvent","_wxPyEvent",SwigwxPyEventTowxCommandEvent); SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxSpinEvent",SwigwxSpinEventTowxCommandEvent); SWIG_RegisterMapping("_class_wxCommandEvent","_wxSpinEvent",SwigwxSpinEventTowxCommandEvent); SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxScrollEvent",SwigwxScrollEventTowxCommandEvent); diff --git a/utils/wxPython/src/msw/events.py b/utils/wxPython/src/msw/events.py index d773d463d6..40699659ba 100644 --- a/utils/wxPython/src/msw/events.py +++ b/utils/wxPython/src/msw/events.py @@ -605,6 +605,29 @@ class wxSysColourChangedEvent(wxSysColourChangedEventPtr): +class wxPyEventPtr(wxCommandEventPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __del__(self): + if self.thisown == 1 : + eventsc.delete_wxPyEvent(self.this) + def SetUserData(self,arg0): + val = eventsc.wxPyEvent_SetUserData(self.this,arg0) + return val + def GetUserData(self): + val = eventsc.wxPyEvent_GetUserData(self.this) + return val + def __repr__(self): + return "" +class wxPyEvent(wxPyEventPtr): + def __init__(self,*args) : + self.this = apply(eventsc.new_wxPyEvent,()+args) + self.thisown = 1 + + + + #-------------- FUNCTION WRAPPERS ------------------ diff --git a/utils/wxPython/src/msw/frames.cpp b/utils/wxPython/src/msw/frames.cpp index a893212bea..47b013bc4f 100644 --- a/utils/wxPython/src/msw/frames.cpp +++ b/utils/wxPython/src/msw/frames.cpp @@ -161,7 +161,7 @@ static PyObject *_wrap_new_wxFrame(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -175,8 +175,12 @@ static PyObject *_wrap_new_wxFrame(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxFrame *)new_wxFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFrame_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxFrame *)new_wxFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFrame_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -201,8 +205,12 @@ static PyObject *_wrap_wxFrame_Centre(PyObject *self, PyObject *args) { return NULL; } } - wxFrame_Centre(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_Centre(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -223,8 +231,12 @@ static PyObject *_wrap_wxFrame_Command(PyObject *self, PyObject *args) { return NULL; } } - wxFrame_Command(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_Command(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -235,7 +247,7 @@ static PyObject *_wrap_wxFrame_CreateStatusBar(PyObject *self, PyObject *args) { wxStatusBar * _result; wxFrame * _arg0; int _arg1 = 1; - long _arg2 = wxST_SIZEGRIP; + long _arg2 = (wxST_SIZEGRIP); wxWindowID _arg3 = -1; char * _arg4 = "statusBar"; char * _argc0 = 0; @@ -250,8 +262,12 @@ static PyObject *_wrap_wxFrame_CreateStatusBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxStatusBar *)wxFrame_CreateStatusBar(_arg0,_arg1,_arg2,_arg3,_arg4); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxStatusBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxStatusBar *)wxFrame_CreateStatusBar(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxStatusBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -276,8 +292,12 @@ static PyObject *_wrap_wxFrame_CreateToolBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxToolBar *)wxFrame_CreateToolBar(_arg0,_arg1,_arg2,_arg3); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolBar *)wxFrame_CreateToolBar(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -299,8 +319,12 @@ static PyObject *_wrap_wxFrame_GetMenuBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMenuBar *)wxFrame_GetMenuBar(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenuBar *)wxFrame_GetMenuBar(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -322,8 +346,12 @@ static PyObject *_wrap_wxFrame_GetStatusBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxStatusBar *)wxFrame_GetStatusBar(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxStatusBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxStatusBar *)wxFrame_GetStatusBar(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxStatusBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -344,8 +372,12 @@ static PyObject *_wrap_wxFrame_GetTitle(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxFrame_GetTitle(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFrame_GetTitle(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -371,8 +403,12 @@ static PyObject *_wrap_wxFrame_GetToolBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxToolBar *)wxFrame_GetToolBar(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolBar *)wxFrame_GetToolBar(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -395,8 +431,12 @@ static PyObject *_wrap_wxFrame_Iconize(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxFrame_Iconize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_Iconize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -417,8 +457,12 @@ static PyObject *_wrap_wxFrame_IsIconized(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxFrame_IsIconized(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxFrame_IsIconized(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -440,8 +484,12 @@ static PyObject *_wrap_wxFrame_Maximize(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxFrame_Maximize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_Maximize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -469,8 +517,12 @@ static PyObject *_wrap_wxFrame_SetAcceleratorTable(PyObject *self, PyObject *arg return NULL; } } - wxFrame_SetAcceleratorTable(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetAcceleratorTable(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -498,8 +550,12 @@ static PyObject *_wrap_wxFrame_SetIcon(PyObject *self, PyObject *args) { return NULL; } } - wxFrame_SetIcon(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetIcon(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -527,8 +583,12 @@ static PyObject *_wrap_wxFrame_SetMenuBar(PyObject *self, PyObject *args) { return NULL; } } - wxFrame_SetMenuBar(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetMenuBar(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -556,8 +616,12 @@ static PyObject *_wrap_wxFrame_SetStatusBar(PyObject *self, PyObject *args) { return NULL; } } - wxFrame_SetStatusBar(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetStatusBar(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -585,10 +649,14 @@ static PyObject *_wrap_wxFrame_SetStatusText(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFrame_SetStatusText(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetStatusText(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -623,10 +691,19 @@ static PyObject *_wrap_wxFrame_SetStatusWidths(PyObject *self, PyObject *args) { } } { - _arg1 = PyList_Size(_obj2); + if (_obj2) { + _arg1 = PyList_Size(_obj2); + } + else { + _arg1 = 0; + } } - wxFrame_SetStatusWidths(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetStatusWidths(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { delete [] _arg2; @@ -656,10 +733,14 @@ static PyObject *_wrap_wxFrame_SetTitle(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFrame_SetTitle(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetTitle(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -691,8 +772,12 @@ static PyObject *_wrap_wxFrame_SetToolBar(PyObject *self, PyObject *args) { return NULL; } } - wxFrame_SetToolBar(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFrame_SetToolBar(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -752,7 +837,7 @@ static PyObject *_wrap_new_wxMiniFrame(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -766,8 +851,12 @@ static PyObject *_wrap_new_wxMiniFrame(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMiniFrame *)new_wxMiniFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMiniFrame_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMiniFrame *)new_wxMiniFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMiniFrame_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -856,6 +945,7 @@ SWIGEXPORT(void,initframesc)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); @@ -886,6 +976,7 @@ SWIGEXPORT(void,initframesc)() { SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0); diff --git a/utils/wxPython/src/msw/gdi.cpp b/utils/wxPython/src/msw/gdi.cpp index 322425e7b7..d98b2f5faf 100644 --- a/utils/wxPython/src/msw/gdi.cpp +++ b/utils/wxPython/src/msw/gdi.cpp @@ -123,9 +123,10 @@ static char* wxStringErrorMsg = "string type is required for parameter"; 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. + // 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); } @@ -202,8 +203,12 @@ static PyObject *_wrap_wxEmptyBitmap(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"ii|i:wxEmptyBitmap",&_arg0,&_arg1,&_arg2)) return NULL; - _result = (wxBitmap *)wxEmptyBitmap(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxEmptyBitmap(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -218,8 +223,12 @@ static PyObject *_wrap_wxNoRefBitmap(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"sl:wxNoRefBitmap",&_arg0,&_arg1)) return NULL; - _result = (wxBitmap *)wxNoRefBitmap(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxNoRefBitmap(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -248,8 +257,12 @@ static PyObject *_wrap_wxMaskColour(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMask *)wxMaskColour(*_arg0,*_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMask_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMask *)wxMaskColour(*_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMask_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -263,8 +276,12 @@ static PyObject *_wrap_wxStockCursor(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"i:wxStockCursor",&_arg0)) return NULL; - _result = (wxCursor *)wxPyStockCursor(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxCursor_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxCursor *)wxPyStockCursor(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxCursor_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -284,10 +301,14 @@ static PyObject *_wrap_wxNamedColour(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (wxColour *)wxNamedColour(*_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxColour *)wxNamedColour(*_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -312,8 +333,12 @@ static PyObject *_wrap_wxMemoryDCFromDC(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMemoryDC *)wxMemoryDCFromDC(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMemoryDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMemoryDC *)wxMemoryDCFromDC(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMemoryDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -965,10 +990,14 @@ static PyObject *_wrap_new_wxBitmap(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (wxBitmap *)new_wxBitmap(*_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)new_wxBitmap(*_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -992,8 +1021,12 @@ static PyObject *_wrap_delete_wxBitmap(PyObject *self, PyObject *args) { return NULL; } } - delete_wxBitmap(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxBitmap(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1016,8 +1049,12 @@ static PyObject *_wrap_wxBitmap_Create(PyObject *self, PyObject *args) { return NULL; } } - wxBitmap_Create(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap_Create(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1038,8 +1075,12 @@ static PyObject *_wrap_wxBitmap_GetDepth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxBitmap_GetDepth(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxBitmap_GetDepth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1059,8 +1100,12 @@ static PyObject *_wrap_wxBitmap_GetHeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxBitmap_GetHeight(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxBitmap_GetHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1081,8 +1126,12 @@ static PyObject *_wrap_wxBitmap_GetPalette(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxPalette *)wxBitmap_GetPalette(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPalette_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPalette *)wxBitmap_GetPalette(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPalette_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1104,8 +1153,12 @@ static PyObject *_wrap_wxBitmap_GetMask(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMask *)wxBitmap_GetMask(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMask_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMask *)wxBitmap_GetMask(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMask_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1126,8 +1179,12 @@ static PyObject *_wrap_wxBitmap_GetWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxBitmap_GetWidth(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxBitmap_GetWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1155,10 +1212,14 @@ static PyObject *_wrap_wxBitmap_LoadFile(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxBitmap_LoadFile(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxBitmap_LoadFile(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -1182,8 +1243,12 @@ static PyObject *_wrap_wxBitmap_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxBitmap_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxBitmap_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1213,7 +1278,7 @@ static PyObject *_wrap_wxBitmap_SaveFile(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPalette_p")) { @@ -1221,8 +1286,12 @@ static PyObject *_wrap_wxBitmap_SaveFile(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxBitmap_SaveFile(_arg0,*_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxBitmap_SaveFile(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -1246,8 +1315,12 @@ static PyObject *_wrap_wxBitmap_SetDepth(PyObject *self, PyObject *args) { return NULL; } } - wxBitmap_SetDepth(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap_SetDepth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1268,8 +1341,12 @@ static PyObject *_wrap_wxBitmap_SetHeight(PyObject *self, PyObject *args) { return NULL; } } - wxBitmap_SetHeight(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap_SetHeight(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1297,8 +1374,12 @@ static PyObject *_wrap_wxBitmap_SetMask(PyObject *self, PyObject *args) { return NULL; } } - wxBitmap_SetMask(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap_SetMask(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1326,8 +1407,12 @@ static PyObject *_wrap_wxBitmap_SetPalette(PyObject *self, PyObject *args) { return NULL; } } - wxBitmap_SetPalette(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap_SetPalette(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1348,8 +1433,12 @@ static PyObject *_wrap_wxBitmap_SetWidth(PyObject *self, PyObject *args) { return NULL; } } - wxBitmap_SetWidth(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBitmap_SetWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1371,8 +1460,12 @@ static PyObject *_wrap_new_wxMask(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMask *)new_wxMask(*_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMask_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMask *)new_wxMask(*_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMask_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1392,8 +1485,12 @@ static PyObject *_wrap_delete_wxMask(PyObject *self, PyObject *args) { return NULL; } } - delete_wxMask(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxMask(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1425,10 +1522,14 @@ static PyObject *_wrap_new_wxIcon(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (wxIcon *)new_wxIcon(*_arg0,_arg1,_arg2,_arg3); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIcon_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIcon *)new_wxIcon(*_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIcon_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -1452,8 +1553,12 @@ static PyObject *_wrap_delete_wxIcon(PyObject *self, PyObject *args) { return NULL; } } - delete_wxIcon(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxIcon(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1474,8 +1579,12 @@ static PyObject *_wrap_wxIcon_GetDepth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxIcon_GetDepth(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxIcon_GetDepth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1495,8 +1604,12 @@ static PyObject *_wrap_wxIcon_GetHeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxIcon_GetHeight(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxIcon_GetHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1516,8 +1629,12 @@ static PyObject *_wrap_wxIcon_GetWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxIcon_GetWidth(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxIcon_GetWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1545,10 +1662,14 @@ static PyObject *_wrap_wxIcon_LoadFile(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxIcon_LoadFile(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxIcon_LoadFile(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -1572,8 +1693,12 @@ static PyObject *_wrap_wxIcon_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxIcon_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxIcon_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1593,8 +1718,12 @@ static PyObject *_wrap_wxIcon_SetDepth(PyObject *self, PyObject *args) { return NULL; } } - wxIcon_SetDepth(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIcon_SetDepth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1615,8 +1744,12 @@ static PyObject *_wrap_wxIcon_SetHeight(PyObject *self, PyObject *args) { return NULL; } } - wxIcon_SetHeight(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIcon_SetHeight(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1637,8 +1770,12 @@ static PyObject *_wrap_wxIcon_SetWidth(PyObject *self, PyObject *args) { return NULL; } } - wxIcon_SetWidth(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIcon_SetWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1670,10 +1807,14 @@ static PyObject *_wrap_new_wxCursor(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (wxCursor *)new_wxCursor(*_arg0,_arg1,_arg2,_arg3); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxCursor_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxCursor *)new_wxCursor(*_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxCursor_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -1697,8 +1838,12 @@ static PyObject *_wrap_delete_wxCursor(PyObject *self, PyObject *args) { return NULL; } } - delete_wxCursor(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxCursor(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1719,8 +1864,12 @@ static PyObject *_wrap_wxCursor_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxCursor_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxCursor_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1744,8 +1893,12 @@ static PyObject *_wrap_new_wxFont(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"iiii|is:new_wxFont",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) return NULL; - _result = (wxFont *)new_wxFont(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxFont *)new_wxFont(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1766,8 +1919,12 @@ static PyObject *_wrap_wxFont_GetFaceName(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxFont_GetFaceName(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFont_GetFaceName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1792,8 +1949,12 @@ static PyObject *_wrap_wxFont_GetFamily(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxFont_GetFamily(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFont_GetFamily(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1813,8 +1974,12 @@ static PyObject *_wrap_wxFont_GetFontId(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxFont_GetFontId(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFont_GetFontId(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1834,8 +1999,12 @@ static PyObject *_wrap_wxFont_GetPointSize(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxFont_GetPointSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFont_GetPointSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1855,8 +2024,12 @@ static PyObject *_wrap_wxFont_GetStyle(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxFont_GetStyle(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFont_GetStyle(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1876,8 +2049,12 @@ static PyObject *_wrap_wxFont_GetUnderlined(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxFont_GetUnderlined(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxFont_GetUnderlined(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1897,8 +2074,12 @@ static PyObject *_wrap_wxFont_GetWeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxFont_GetWeight(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxFont_GetWeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1924,10 +2105,14 @@ static PyObject *_wrap_wxFont_SetFaceName(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxFont_SetFaceName(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont_SetFaceName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1952,8 +2137,12 @@ static PyObject *_wrap_wxFont_SetFamily(PyObject *self, PyObject *args) { return NULL; } } - wxFont_SetFamily(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont_SetFamily(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1974,8 +2163,12 @@ static PyObject *_wrap_wxFont_SetPointSize(PyObject *self, PyObject *args) { return NULL; } } - wxFont_SetPointSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont_SetPointSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1996,8 +2189,12 @@ static PyObject *_wrap_wxFont_SetStyle(PyObject *self, PyObject *args) { return NULL; } } - wxFont_SetStyle(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont_SetStyle(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2020,8 +2217,12 @@ static PyObject *_wrap_wxFont_SetUnderlined(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxFont_SetUnderlined(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont_SetUnderlined(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2042,8 +2243,12 @@ static PyObject *_wrap_wxFont_SetWeight(PyObject *self, PyObject *args) { return NULL; } } - wxFont_SetWeight(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont_SetWeight(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2060,8 +2265,12 @@ static PyObject *_wrap_new_wxColour(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"|bbb:new_wxColour",&_arg0,&_arg1,&_arg2)) return NULL; - _result = (wxColour *)new_wxColour(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxColour *)new_wxColour(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2081,8 +2290,12 @@ static PyObject *_wrap_delete_wxColour(PyObject *self, PyObject *args) { return NULL; } } - delete_wxColour(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxColour(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2103,8 +2316,12 @@ static PyObject *_wrap_wxColour_Red(PyObject *self, PyObject *args) { return NULL; } } - _result = (unsigned char )wxColour_Red(_arg0); - _resultobj = Py_BuildValue("b",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxColour_Red(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); return _resultobj; } @@ -2124,8 +2341,12 @@ static PyObject *_wrap_wxColour_Green(PyObject *self, PyObject *args) { return NULL; } } - _result = (unsigned char )wxColour_Green(_arg0); - _resultobj = Py_BuildValue("b",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxColour_Green(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); return _resultobj; } @@ -2145,8 +2366,12 @@ static PyObject *_wrap_wxColour_Blue(PyObject *self, PyObject *args) { return NULL; } } - _result = (unsigned char )wxColour_Blue(_arg0); - _resultobj = Py_BuildValue("b",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxColour_Blue(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); return _resultobj; } @@ -2166,8 +2391,12 @@ static PyObject *_wrap_wxColour_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxColour_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxColour_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2189,8 +2418,12 @@ static PyObject *_wrap_wxColour_Set(PyObject *self, PyObject *args) { return NULL; } } - wxColour_Set(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour_Set(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2217,8 +2450,12 @@ static PyObject *_wrap_wxColour_Get(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxColour_Get(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxColour_Get(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -2246,8 +2483,12 @@ static PyObject *_wrap_new_wxPen(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxPen *)new_wxPen(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPen_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPen *)new_wxPen(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPen_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2268,8 +2509,12 @@ static PyObject *_wrap_wxPen_GetCap(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPen_GetCap(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPen_GetCap(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2290,9 +2535,13 @@ static PyObject *_wrap_wxPen_GetColour(PyObject *self, PyObject *args) { return NULL; } } - wxColour & _result_ref = wxPen_GetColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxPen_GetColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2313,8 +2562,12 @@ static PyObject *_wrap_wxPen_GetJoin(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPen_GetJoin(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPen_GetJoin(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2334,8 +2587,12 @@ static PyObject *_wrap_wxPen_GetStyle(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPen_GetStyle(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPen_GetStyle(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2355,8 +2612,12 @@ static PyObject *_wrap_wxPen_GetWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPen_GetWidth(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPen_GetWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2376,8 +2637,12 @@ static PyObject *_wrap_wxPen_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxPen_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPen_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2397,8 +2662,12 @@ static PyObject *_wrap_wxPen_SetCap(PyObject *self, PyObject *args) { return NULL; } } - wxPen_SetCap(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen_SetCap(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2426,8 +2695,12 @@ static PyObject *_wrap_wxPen_SetColour(PyObject *self, PyObject *args) { return NULL; } } - wxPen_SetColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen_SetColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2448,8 +2721,12 @@ static PyObject *_wrap_wxPen_SetJoin(PyObject *self, PyObject *args) { return NULL; } } - wxPen_SetJoin(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen_SetJoin(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2470,8 +2747,12 @@ static PyObject *_wrap_wxPen_SetStyle(PyObject *self, PyObject *args) { return NULL; } } - wxPen_SetStyle(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen_SetStyle(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2492,8 +2773,12 @@ static PyObject *_wrap_wxPen_SetWidth(PyObject *self, PyObject *args) { return NULL; } } - wxPen_SetWidth(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen_SetWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2522,8 +2807,12 @@ static PyObject *_wrap_wxPen_GetDashes(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPen_GetDashes(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPen_GetDashes(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2544,8 +2833,12 @@ static PyObject *_wrap_wxPen_GetStipple(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxBitmap *)wxPen_GetStipple(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxPen_GetStipple(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2576,10 +2869,19 @@ static PyObject *_wrap_wxPen_SetDashes(PyObject *self, PyObject *args) { } } { - _arg1 = PyList_Size(_obj2); + if (_obj2) { + _arg1 = PyList_Size(_obj2); + } + else { + _arg1 = 0; + } } - wxPen_SetDashes(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen_SetDashes(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { delete [] _arg2; @@ -2610,8 +2912,12 @@ static PyObject *_wrap_wxPen_SetStipple(PyObject *self, PyObject *args) { return NULL; } } - wxPen_SetStipple(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen_SetStipple(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2637,8 +2943,12 @@ static PyObject *_wrap_new_wxBrush(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxBrush *)new_wxBrush(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBrush *)new_wxBrush(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2660,9 +2970,13 @@ static PyObject *_wrap_wxBrush_GetColour(PyObject *self, PyObject *args) { return NULL; } } - wxColour & _result_ref = wxBrush_GetColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxBrush_GetColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2684,8 +2998,12 @@ static PyObject *_wrap_wxBrush_GetStipple(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxBitmap *)wxBrush_GetStipple(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxBrush_GetStipple(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2706,8 +3024,12 @@ static PyObject *_wrap_wxBrush_GetStyle(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxBrush_GetStyle(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxBrush_GetStyle(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2727,8 +3049,12 @@ static PyObject *_wrap_wxBrush_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxBrush_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxBrush_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2755,8 +3081,12 @@ static PyObject *_wrap_wxBrush_SetColour(PyObject *self, PyObject *args) { return NULL; } } - wxBrush_SetColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBrush_SetColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2784,8 +3114,12 @@ static PyObject *_wrap_wxBrush_SetStipple(PyObject *self, PyObject *args) { return NULL; } } - wxBrush_SetStipple(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBrush_SetStipple(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2806,8 +3140,12 @@ static PyObject *_wrap_wxBrush_SetStyle(PyObject *self, PyObject *args) { return NULL; } } - wxBrush_SetStyle(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBrush_SetStyle(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2827,8 +3165,12 @@ static PyObject *_wrap_delete_wxDC(PyObject *self, PyObject *args) { return NULL; } } - delete_wxDC(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxDC(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2848,8 +3190,12 @@ static PyObject *_wrap_wxDC_BeginDrawing(PyObject *self, PyObject *args) { return NULL; } } - wxDC_BeginDrawing(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_BeginDrawing(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2885,8 +3231,12 @@ static PyObject *_wrap_wxDC_Blit(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxDC_Blit(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxDC_Blit(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2905,8 +3255,12 @@ static PyObject *_wrap_wxDC_Clear(PyObject *self, PyObject *args) { return NULL; } } - wxDC_Clear(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_Clear(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2928,8 +3282,12 @@ static PyObject *_wrap_wxDC_CrossHair(PyObject *self, PyObject *args) { return NULL; } } - wxDC_CrossHair(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_CrossHair(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2949,8 +3307,12 @@ static PyObject *_wrap_wxDC_DestroyClippingRegion(PyObject *self, PyObject *args return NULL; } } - wxDC_DestroyClippingRegion(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DestroyClippingRegion(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2972,8 +3334,12 @@ static PyObject *_wrap_wxDC_DeviceToLogicalX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_DeviceToLogicalX(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_DeviceToLogicalX(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -2994,8 +3360,12 @@ static PyObject *_wrap_wxDC_DeviceToLogicalXRel(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxDC_DeviceToLogicalXRel(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_DeviceToLogicalXRel(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3016,8 +3386,12 @@ static PyObject *_wrap_wxDC_DeviceToLogicalY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_DeviceToLogicalY(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_DeviceToLogicalY(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3038,8 +3412,12 @@ static PyObject *_wrap_wxDC_DeviceToLogicalYRel(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxDC_DeviceToLogicalYRel(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_DeviceToLogicalYRel(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3064,8 +3442,12 @@ static PyObject *_wrap_wxDC_DrawArc(PyObject *self, PyObject *args) { return NULL; } } - wxDC_DrawArc(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawArc(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3089,8 +3471,12 @@ static PyObject *_wrap_wxDC_DrawEllipse(PyObject *self, PyObject *args) { return NULL; } } - wxDC_DrawEllipse(_arg0,_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawEllipse(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3116,8 +3502,12 @@ static PyObject *_wrap_wxDC_DrawEllipticArc(PyObject *self, PyObject *args) { return NULL; } } - wxDC_DrawEllipticArc(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawEllipticArc(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3147,8 +3537,12 @@ static PyObject *_wrap_wxDC_DrawIcon(PyObject *self, PyObject *args) { return NULL; } } - wxDC_DrawIcon(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawIcon(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3172,8 +3566,12 @@ static PyObject *_wrap_wxDC_DrawLine(PyObject *self, PyObject *args) { return NULL; } } - wxDC_DrawLine(_arg0,_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawLine(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3206,10 +3604,19 @@ static PyObject *_wrap_wxDC_DrawLines(PyObject *self, PyObject *args) { } } { - _arg1 = PyList_Size(_obj2); + if (_obj2) { + _arg1 = PyList_Size(_obj2); + } + else { + _arg1 = 0; + } } - wxDC_DrawLines(_arg0,_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawLines(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { delete [] _arg2; @@ -3246,10 +3653,19 @@ static PyObject *_wrap_wxDC_DrawPolygon(PyObject *self, PyObject *args) { } } { - _arg1 = PyList_Size(_obj2); + if (_obj2) { + _arg1 = PyList_Size(_obj2); + } + else { + _arg1 = 0; + } } - wxDC_DrawPolygon(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawPolygon(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { delete [] _arg2; @@ -3274,8 +3690,12 @@ static PyObject *_wrap_wxDC_DrawPoint(PyObject *self, PyObject *args) { return NULL; } } - wxDC_DrawPoint(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawPoint(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3299,8 +3719,12 @@ static PyObject *_wrap_wxDC_DrawRectangle(PyObject *self, PyObject *args) { return NULL; } } - wxDC_DrawRectangle(_arg0,_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawRectangle(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3325,8 +3749,12 @@ static PyObject *_wrap_wxDC_DrawRoundedRectangle(PyObject *self, PyObject *args) return NULL; } } - wxDC_DrawRoundedRectangle(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawRoundedRectangle(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3357,10 +3785,19 @@ static PyObject *_wrap_wxDC_DrawSpline(PyObject *self, PyObject *args) { } } { - _arg1 = PyList_Size(_obj2); + if (_obj2) { + _arg1 = PyList_Size(_obj2); + } + else { + _arg1 = 0; + } } - wxDC_DrawSpline(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawSpline(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { delete [] _arg2; @@ -3392,10 +3829,14 @@ static PyObject *_wrap_wxDC_DrawText(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxDC_DrawText(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawText(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -3419,8 +3860,12 @@ static PyObject *_wrap_wxDC_EndDoc(PyObject *self, PyObject *args) { return NULL; } } - wxDC_EndDoc(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_EndDoc(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3440,8 +3885,12 @@ static PyObject *_wrap_wxDC_EndDrawing(PyObject *self, PyObject *args) { return NULL; } } - wxDC_EndDrawing(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_EndDrawing(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3461,8 +3910,12 @@ static PyObject *_wrap_wxDC_EndPage(PyObject *self, PyObject *args) { return NULL; } } - wxDC_EndPage(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_EndPage(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3493,8 +3946,12 @@ static PyObject *_wrap_wxDC_FloodFill(PyObject *self, PyObject *args) { return NULL; } } - wxDC_FloodFill(_arg0,_arg1,_arg2,*_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_FloodFill(_arg0,_arg1,_arg2,*_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3516,9 +3973,13 @@ static PyObject *_wrap_wxDC_GetBackground(PyObject *self, PyObject *args) { return NULL; } } - wxBrush & _result_ref = wxDC_GetBackground(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBrush & _result_ref = wxDC_GetBackground(_arg0); _result = (wxBrush *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3540,9 +4001,13 @@ static PyObject *_wrap_wxDC_GetBrush(PyObject *self, PyObject *args) { return NULL; } } - wxBrush & _result_ref = wxDC_GetBrush(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBrush & _result_ref = wxDC_GetBrush(_arg0); _result = (wxBrush *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3563,8 +4028,12 @@ static PyObject *_wrap_wxDC_GetCharHeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_GetCharHeight(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_GetCharHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3584,8 +4053,12 @@ static PyObject *_wrap_wxDC_GetCharWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_GetCharWidth(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_GetCharWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3624,8 +4097,12 @@ static PyObject *_wrap_wxDC_GetClippingBox(PyObject *self, PyObject *args) { return NULL; } } - wxDC_GetClippingBox(_arg0,_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_GetClippingBox(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -3667,9 +4144,13 @@ static PyObject *_wrap_wxDC_GetFont(PyObject *self, PyObject *args) { return NULL; } } - wxFont & _result_ref = wxDC_GetFont(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont & _result_ref = wxDC_GetFont(_arg0); _result = (wxFont *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3690,8 +4171,12 @@ static PyObject *_wrap_wxDC_GetLogicalFunction(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxDC_GetLogicalFunction(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxDC_GetLogicalFunction(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3711,8 +4196,12 @@ static PyObject *_wrap_wxDC_GetMapMode(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxDC_GetMapMode(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxDC_GetMapMode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3732,8 +4221,12 @@ static PyObject *_wrap_wxDC_GetOptimization(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxDC_GetOptimization(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxDC_GetOptimization(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3754,9 +4247,13 @@ static PyObject *_wrap_wxDC_GetPen(PyObject *self, PyObject *args) { return NULL; } } - wxPen & _result_ref = wxDC_GetPen(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPen & _result_ref = wxDC_GetPen(_arg0); _result = (wxPen *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPen_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPen_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3784,8 +4281,12 @@ static PyObject *_wrap_wxDC_GetPixel(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxColour *)wxDC_GetPixel(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxColour *)wxDC_GetPixel(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3815,8 +4316,12 @@ static PyObject *_wrap_wxDC_GetSize(PyObject *self, PyObject *args) { return NULL; } } - wxDC_GetSize(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_GetSize(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -3848,9 +4353,13 @@ static PyObject *_wrap_wxDC_GetTextBackground(PyObject *self, PyObject *args) { return NULL; } } - wxColour & _result_ref = wxDC_GetTextBackground(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxDC_GetTextBackground(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3887,10 +4396,14 @@ static PyObject *_wrap_wxDC_GetTextExtent(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxDC_GetTextExtent(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_GetTextExtent(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -3953,7 +4466,7 @@ static PyObject *_wrap_wxDC_GetFullTextExtent(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_argc6) { if (SWIG_GetPtr(_argc6,(void **) &_arg6,"_wxFont_p")) { @@ -3961,8 +4474,12 @@ static PyObject *_wrap_wxDC_GetFullTextExtent(PyObject *self, PyObject *args) { return NULL; } } - wxDC_GetFullTextExtent(_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_GetFullTextExtent(_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -4008,9 +4525,13 @@ static PyObject *_wrap_wxDC_GetTextForeground(PyObject *self, PyObject *args) { return NULL; } } - wxColour & _result_ref = wxDC_GetTextForeground(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxDC_GetTextForeground(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4032,8 +4553,12 @@ static PyObject *_wrap_wxDC_LogicalToDeviceX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_LogicalToDeviceX(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_LogicalToDeviceX(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4054,8 +4579,12 @@ static PyObject *_wrap_wxDC_LogicalToDeviceXRel(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxDC_LogicalToDeviceXRel(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_LogicalToDeviceXRel(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4076,8 +4605,12 @@ static PyObject *_wrap_wxDC_LogicalToDeviceY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_LogicalToDeviceY(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_LogicalToDeviceY(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4098,8 +4631,12 @@ static PyObject *_wrap_wxDC_LogicalToDeviceYRel(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxDC_LogicalToDeviceYRel(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_LogicalToDeviceYRel(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4119,8 +4656,12 @@ static PyObject *_wrap_wxDC_MaxX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_MaxX(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_MaxX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4140,8 +4681,12 @@ static PyObject *_wrap_wxDC_MaxY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_MaxY(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_MaxY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4161,8 +4706,12 @@ static PyObject *_wrap_wxDC_MinX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_MinX(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_MinX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4182,8 +4731,12 @@ static PyObject *_wrap_wxDC_MinY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxDC_MinY(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxDC_MinY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -4203,8 +4756,12 @@ static PyObject *_wrap_wxDC_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxDC_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxDC_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4225,8 +4782,12 @@ static PyObject *_wrap_wxDC_SetDeviceOrigin(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetDeviceOrigin(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetDeviceOrigin(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4254,8 +4815,12 @@ static PyObject *_wrap_wxDC_SetBackground(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetBackground(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetBackground(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4276,8 +4841,12 @@ static PyObject *_wrap_wxDC_SetBackgroundMode(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetBackgroundMode(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetBackgroundMode(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4301,8 +4870,12 @@ static PyObject *_wrap_wxDC_SetClippingRegion(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetClippingRegion(_arg0,_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetClippingRegion(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4330,8 +4903,12 @@ static PyObject *_wrap_wxDC_SetPalette(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetPalette(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetPalette(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4359,8 +4936,12 @@ static PyObject *_wrap_wxDC_SetBrush(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetBrush(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetBrush(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4388,8 +4969,12 @@ static PyObject *_wrap_wxDC_SetFont(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetFont(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4410,8 +4995,12 @@ static PyObject *_wrap_wxDC_SetLogicalFunction(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetLogicalFunction(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetLogicalFunction(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4432,8 +5021,12 @@ static PyObject *_wrap_wxDC_SetMapMode(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetMapMode(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetMapMode(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4456,8 +5049,12 @@ static PyObject *_wrap_wxDC_SetOptimization(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxDC_SetOptimization(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetOptimization(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4485,8 +5082,12 @@ static PyObject *_wrap_wxDC_SetPen(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetPen(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetPen(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4514,8 +5115,12 @@ static PyObject *_wrap_wxDC_SetTextBackground(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetTextBackground(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetTextBackground(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4543,8 +5148,12 @@ static PyObject *_wrap_wxDC_SetTextForeground(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetTextForeground(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetTextForeground(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4566,8 +5175,12 @@ static PyObject *_wrap_wxDC_SetUserScale(PyObject *self, PyObject *args) { return NULL; } } - wxDC_SetUserScale(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_SetUserScale(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4595,10 +5208,14 @@ static PyObject *_wrap_wxDC_StartDoc(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxDC_StartDoc(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxDC_StartDoc(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -4621,8 +5238,12 @@ static PyObject *_wrap_wxDC_StartPage(PyObject *self, PyObject *args) { return NULL; } } - wxDC_StartPage(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_StartPage(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4664,8 +5285,12 @@ static PyObject *_wrap_wxDC_DrawBitmap(PyObject *self, PyObject *args) { } } _arg4 = (bool ) tempbool4; - wxDC_DrawBitmap(_arg0,*_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDC_DrawBitmap(_arg0,*_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4687,8 +5312,12 @@ static PyObject *_wrap_new_wxMemoryDC(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxMemoryDC")) return NULL; - _result = (wxMemoryDC *)new_wxMemoryDC(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMemoryDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMemoryDC *)new_wxMemoryDC(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMemoryDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4716,8 +5345,12 @@ static PyObject *_wrap_wxMemoryDC_SelectObject(PyObject *self, PyObject *args) { return NULL; } } - wxMemoryDC_SelectObject(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMemoryDC_SelectObject(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4739,8 +5372,12 @@ static PyObject *_wrap_new_wxScreenDC(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxScreenDC")) return NULL; - _result = (wxScreenDC *)new_wxScreenDC(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxScreenDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxScreenDC *)new_wxScreenDC(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxScreenDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4769,8 +5406,12 @@ static PyObject *_wrap_wxScreenDC_StartDrawingOnTop(PyObject *self, PyObject *ar return NULL; } } - _result = (bool )wxScreenDC_StartDrawingOnTop(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxScreenDC_StartDrawingOnTop(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4798,8 +5439,12 @@ static PyObject *_wrap_wxScreenDC_StartDrawingOnTopRect(PyObject *self, PyObject return NULL; } } - _result = (bool )wxScreenDC_StartDrawingOnTopRect(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxScreenDC_StartDrawingOnTopRect(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4819,8 +5464,12 @@ static PyObject *_wrap_wxScreenDC_EndDrawingOnTop(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxScreenDC_EndDrawingOnTop(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxScreenDC_EndDrawingOnTop(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4849,8 +5498,12 @@ static PyObject *_wrap_new_wxClientDC(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxClientDC *)new_wxClientDC(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxClientDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxClientDC *)new_wxClientDC(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxClientDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4880,8 +5533,12 @@ static PyObject *_wrap_new_wxPaintDC(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxPaintDC *)new_wxPaintDC(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPaintDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPaintDC *)new_wxPaintDC(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPaintDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4911,8 +5568,12 @@ static PyObject *_wrap_new_wxWindowDC(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindowDC *)new_wxWindowDC(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindowDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindowDC *)new_wxWindowDC(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindowDC_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4948,25 +5609,29 @@ static PyObject *_wrap_new_wxPrinterDC(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } { if (!PyString_Check(_obj1)) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } { if (!PyString_Check(_obj2)) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } _arg3 = (bool ) tempbool3; - _result = (wxPrinterDC *)new_wxPrinterDC(*_arg0,*_arg1,*_arg2,_arg3,_arg4); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrinterDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPrinterDC *)new_wxPrinterDC(*_arg0,*_arg1,*_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPrinterDC_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -5008,10 +5673,14 @@ static PyObject *_wrap_new_wxMetaFileDC(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (wxMetaFileDC *)new_wxMetaFileDC(*_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMetaFileDC_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMetaFileDC *)new_wxMetaFileDC(*_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMetaFileDC_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -5037,8 +5706,12 @@ static PyObject *_wrap_wxMetaFileDC_Close(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMetaFile *)wxMetaFileDC_Close(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMetaFile_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMetaFile *)wxMetaFileDC_Close(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMetaFile_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -5079,10 +5752,19 @@ static PyObject *_wrap_new_wxPalette(PyObject *self, PyObject *args) { } } { - _arg0 = PyList_Size(_obj1); + if (_obj1) { + _arg0 = PyList_Size(_obj1); + } + else { + _arg0 = 0; + } } - _result = (wxPalette *)new_wxPalette(_arg0,_arg1,_arg2,_arg3); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPalette_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPalette *)new_wxPalette(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPalette_p"); _resultobj = Py_BuildValue("s",_ptemp); { delete [] _arg1; @@ -5111,8 +5793,12 @@ static PyObject *_wrap_delete_wxPalette(PyObject *self, PyObject *args) { return NULL; } } - delete_wxPalette(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxPalette(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5136,8 +5822,12 @@ static PyObject *_wrap_wxPalette_GetPixel(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPalette_GetPixel(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPalette_GetPixel(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5182,8 +5872,12 @@ static PyObject *_wrap_wxPalette_GetRGB(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxPalette_GetRGB(_arg0,_arg1,_arg2,_arg3,_arg4); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPalette_GetRGB(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5203,8 +5897,12 @@ static PyObject *_wrap_wxPalette_Ok(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxPalette_Ok(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPalette_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5223,8 +5921,12 @@ static PyObject *_wrap_new_wxImageList(PyObject *self, PyObject *args) { if(!PyArg_ParseTuple(args,"ii|ii:new_wxImageList",&_arg0,&_arg1,&tempbool2,&_arg3)) return NULL; _arg2 = (bool ) tempbool2; - _result = (wxImageList *)new_wxImageList(_arg0,_arg1,_arg2,_arg3); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImageList *)new_wxImageList(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -5244,8 +5946,12 @@ static PyObject *_wrap_delete_wxImageList(PyObject *self, PyObject *args) { return NULL; } } - delete_wxImageList(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxImageList(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -5282,8 +5988,12 @@ static PyObject *_wrap_wxImageList_Add(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxImageList_Add(_arg0,*_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxImageList_Add(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5319,8 +6029,12 @@ static PyObject *_wrap_wxImageList_AddWithColourMask(PyObject *self, PyObject *a return NULL; } } - _result = (int )wxImageList_AddWithColourMask(_arg0,*_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxImageList_AddWithColourMask(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5348,8 +6062,12 @@ static PyObject *_wrap_wxImageList_AddIcon(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxImageList_AddIcon(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxImageList_AddIcon(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5386,8 +6104,12 @@ static PyObject *_wrap_wxImageList_Replace(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxImageList_Replace(_arg0,_arg1,*_arg2,*_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImageList_Replace(_arg0,_arg1,*_arg2,*_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5416,8 +6138,12 @@ static PyObject *_wrap_wxImageList_ReplaceIcon(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxImageList_ReplaceIcon(_arg0,_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImageList_ReplaceIcon(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5452,8 +6178,12 @@ static PyObject *_wrap_wxImageList_Draw(PyObject *self, PyObject *args) { } } _arg6 = (bool ) tempbool6; - _result = (bool )wxImageList_Draw(_arg0,_arg1,*_arg2,_arg3,_arg4,_arg5,_arg6); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImageList_Draw(_arg0,_arg1,*_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5473,8 +6203,12 @@ static PyObject *_wrap_wxImageList_GetImageCount(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxImageList_GetImageCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxImageList_GetImageCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5495,8 +6229,12 @@ static PyObject *_wrap_wxImageList_Remove(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxImageList_Remove(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImageList_Remove(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -5516,8 +6254,12 @@ static PyObject *_wrap_wxImageList_RemoveAll(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxImageList_RemoveAll(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImageList_RemoveAll(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } diff --git a/utils/wxPython/src/msw/glcanvas.cpp b/utils/wxPython/src/msw/glcanvas.cpp new file mode 100644 index 0000000000..9e31f8ddfd --- /dev/null +++ b/utils/wxPython/src/msw/glcanvas.cpp @@ -0,0 +1,9770 @@ +/* + * FILE : msw/glcanvas.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 +#include +/* 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 initglcanvasc + +#define SWIG_name "glcanvasc" + +#include "helpers.h" +#include + +static PyObject* l_output_helper(PyObject* target, PyObject* o) { + PyObject* o2; + if (!target) { + target = o; + } else if (target == Py_None) { + Py_DECREF(Py_None); + target = o; + } else { + if (!PyList_Check(target)) { + o2 = target; + target = PyList_New(0); + PyList_Append(target, o2); + Py_XDECREF(o2); + } + PyList_Append(target,o); + Py_XDECREF(o); + } + return target; +} + +static PyObject* t_output_helper(PyObject* target, PyObject* o) { + PyObject* o2; + PyObject* o3; + + if (!target) { + target = o; + } else if (target == Py_None) { + Py_DECREF(Py_None); + target = o; + } else { + if (!PyTuple_Check(target)) { + o2 = target; + target = PyTuple_New(1); + PyTuple_SetItem(target, 0, o2); + } + o3 = PyTuple_New(1); + PyTuple_SetItem(o3, 0, o); + + o2 = target; + target = PySequence_Concat(o2, o3); + Py_DECREF(o2); + Py_DECREF(o3); + } + return target; +} + + +extern byte* byte_LIST_helper(PyObject* source); +extern int* int_LIST_helper(PyObject* source); +extern long* long_LIST_helper(PyObject* source); +extern char** string_LIST_helper(PyObject* source); +extern wxPoint* wxPoint_LIST_helper(PyObject* source); +extern wxBitmap** wxBitmap_LIST_helper(PyObject* source); +extern wxString* wxString_LIST_helper(PyObject* source); +extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source); + + +static char* wxStringErrorMsg = "string type is required for parameter"; + +#ifdef SEPARATE + static wxString wxPyEmptyStr(""); + static wxPoint wxPyDefaultPosition(-1, -1); + static wxSize wxPyDefaultSize(-1, -1); +#endif +static PyObject *_wrap_glArrayElementEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glArrayElementEXT",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glArrayElementEXT(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColorPointerEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLenum _arg1; + GLsizei _arg2; + GLsizei _arg3; + GLvoid * _arg4; + char * _argc4 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiis:glColorPointerEXT",&_arg0,&_arg1,&_arg2,&_arg3,&_argc4)) + return NULL; + if (_argc4) { + if (SWIG_GetPtr(_argc4,(void **) &_arg4,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of glColorPointerEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColorPointerEXT(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDrawArraysEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLsizei _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glDrawArraysEXT",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDrawArraysEXT(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEdgeFlagPointerEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLsizei _arg1; + GLboolean * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glEdgeFlagPointerEXT",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLboolean_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glEdgeFlagPointerEXT. Expected _GLboolean_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glEdgeFlagPointerEXT(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetPointervEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLvoid ** _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetPointervEXT",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetPointervEXT. Expected _GLvoid_pp."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetPointervEXT(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexPointerEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLsizei _arg2; + GLvoid * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glIndexPointerEXT",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glIndexPointerEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexPointerEXT(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormalPointerEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLsizei _arg2; + GLvoid * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glNormalPointerEXT",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glNormalPointerEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormalPointerEXT(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoordPointerEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLenum _arg1; + GLsizei _arg2; + GLsizei _arg3; + GLvoid * _arg4; + char * _argc4 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiis:glTexCoordPointerEXT",&_arg0,&_arg1,&_arg2,&_arg3,&_argc4)) + return NULL; + if (_argc4) { + if (SWIG_GetPtr(_argc4,(void **) &_arg4,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of glTexCoordPointerEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoordPointerEXT(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertexPointerEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLenum _arg1; + GLsizei _arg2; + GLsizei _arg3; + GLvoid * _arg4; + char * _argc4 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiis:glVertexPointerEXT",&_arg0,&_arg1,&_arg2,&_arg3,&_argc4)) + return NULL; + if (_argc4) { + if (SWIG_GetPtr(_argc4,(void **) &_arg4,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of glVertexPointerEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertexPointerEXT(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColorSubtableEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLsizei _arg2; + GLenum _arg3; + GLenum _arg4; + GLvoid * _arg5; + char * _argc5 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiis:glColorSubtableEXT",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_argc5)) + return NULL; + if (_argc5) { + if (SWIG_GetPtr(_argc5,(void **) &_arg5,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of glColorSubtableEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColorSubtableEXT(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColorTableEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLsizei _arg2; + GLenum _arg3; + GLenum _arg4; + GLvoid * _arg5; + char * _argc5 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiis:glColorTableEXT",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_argc5)) + return NULL; + if (_argc5) { + if (SWIG_GetPtr(_argc5,(void **) &_arg5,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of glColorTableEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColorTableEXT(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCopyColorTableEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint _arg2; + GLint _arg3; + GLsizei _arg4; + + self = self; + if(!PyArg_ParseTuple(args,"iiiii:glCopyColorTableEXT",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCopyColorTableEXT(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetColorTableEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLenum _arg2; + GLvoid * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glGetColorTableEXT",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glGetColorTableEXT. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetColorTableEXT(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetColorTableParamaterfvEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetColorTableParamaterfvEXT",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetColorTableParamaterfvEXT. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetColorTableParamaterfvEXT(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetColorTavleParameterivEXT(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetColorTavleParameterivEXT",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetColorTavleParameterivEXT. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetColorTavleParameterivEXT(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLockArraysSGI(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLsizei _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glLockArraysSGI",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLockArraysSGI(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glUnlockArraysSGI(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glUnlockArraysSGI")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glUnlockArraysSGI(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCullParameterdvSGI(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLdouble * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glCullParameterdvSGI",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glCullParameterdvSGI. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glCullParameterdvSGI(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCullParameterfvSGI(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glCullParameterfvSGI",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glCullParameterfvSGI. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glCullParameterfvSGI(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexFuncSGI(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLclampf _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"if:glIndexFuncSGI",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexFuncSGI(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexMaterialSGI(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glIndexMaterialSGI",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexMaterialSGI(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glAddSwapHintRectWin(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLsizei _arg2; + GLsizei _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glAddSwapHintRectWin",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glAddSwapHintRectWin(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glAccum(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"if:glAccum",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glAccum(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glAlphaFunc(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLclampf _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"if:glAlphaFunc",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glAlphaFunc(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glAreTexturesResident(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean _result; + GLsizei _arg0; + GLuint * _arg1; + GLboolean * _arg2; + char * _argc1 = 0; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iss:glAreTexturesResident",&_arg0,&_argc1,&_argc2)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glAreTexturesResident. Expected _GLuint_p."); + return NULL; + } + } + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLboolean_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glAreTexturesResident. Expected _GLboolean_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLboolean )glAreTexturesResident(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +static PyObject *_wrap_glArrayElement(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glArrayElement",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glArrayElement(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glBegin(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glBegin",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glBegin(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glBindTexture(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLuint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glBindTexture",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glBindTexture(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glBitmap(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLsizei _arg1; + GLfloat _arg2; + GLfloat _arg3; + GLfloat _arg4; + GLfloat _arg5; + GLubyte * _arg6; + char * _argc6 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiffffs:glBitmap",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_argc6)) + return NULL; + if (_argc6) { + if (SWIG_GetPtr(_argc6,(void **) &_arg6,"_GLubyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of glBitmap. Expected _GLubyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glBitmap(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glBlendFunc(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glBlendFunc",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glBlendFunc(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCallList(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glCallList",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCallList(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCallLists(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLenum _arg1; + GLvoid * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glCallLists",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glCallLists. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glCallLists(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glClear(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbitfield _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glClear",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glClear(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glClearAccum(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLfloat _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glClearAccum",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glClearAccum(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glClearColor(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLclampf _arg0; + GLclampf _arg1; + GLclampf _arg2; + GLclampf _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glClearColor",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glClearColor(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glClearDepth(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLclampd _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"d:glClearDepth",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glClearDepth(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glClearIndex(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"f:glClearIndex",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glClearIndex(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glClearStencil(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glClearStencil",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glClearStencil(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glClipPlane(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLdouble * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glClipPlane",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glClipPlane. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glClipPlane(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3b(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbyte _arg0; + GLbyte _arg1; + GLbyte _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"bbb:glColor3b",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3b(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3bv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3bv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLbyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3bv. Expected _GLbyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3bv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"ddd:glColor3d",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3d(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"fff:glColor3f",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3f(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glColor3i",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3i(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"hhh:glColor3s",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3s(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3ub(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte _arg0; + GLubyte _arg1; + GLubyte _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"bbb:glColor3ub",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3ub(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3ubv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3ubv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLubyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3ubv. Expected _GLubyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3ubv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3ui(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + GLuint _arg1; + GLuint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glColor3ui",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3ui(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3uiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3uiv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3uiv. Expected _GLuint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3uiv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3us(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLushort _arg0; + GLushort _arg1; + GLushort _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"hhh:glColor3us",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3us(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor3usv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLushort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor3usv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLushort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor3usv. Expected _GLushort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor3usv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4b(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbyte _arg0; + GLbyte _arg1; + GLbyte _arg2; + GLbyte _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"bbbb:glColor4b",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4b(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4bv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4bv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLbyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4bv. Expected _GLbyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4bv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"dddd:glColor4d",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4d(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLfloat _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glColor4f",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4f(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glColor4i",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4i(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + GLshort _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"hhhh:glColor4s",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4s(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4ub(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte _arg0; + GLubyte _arg1; + GLubyte _arg2; + GLubyte _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"bbbb:glColor4ub",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4ub(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4ubv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4ubv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLubyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4ubv. Expected _GLubyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4ubv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4ui(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + GLuint _arg1; + GLuint _arg2; + GLuint _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glColor4ui",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4ui(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4uiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4uiv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4uiv. Expected _GLuint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4uiv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4us(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLushort _arg0; + GLushort _arg1; + GLushort _arg2; + GLushort _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"hhhh:glColor4us",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4us(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColor4usv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLushort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glColor4usv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLushort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glColor4usv. Expected _GLushort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColor4usv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColorMask(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean _arg0; + GLboolean _arg1; + GLboolean _arg2; + GLboolean _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"bbbb:glColorMask",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColorMask(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColorMaterial(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glColorMaterial",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glColorMaterial(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glColorPointer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLenum _arg1; + GLsizei _arg2; + GLvoid * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glColorPointer",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glColorPointer. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glColorPointer(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCopyPixels(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLsizei _arg2; + GLsizei _arg3; + GLenum _arg4; + + self = self; + if(!PyArg_ParseTuple(args,"iiiii:glCopyPixels",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCopyPixels(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCopyTexImage1D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLenum _arg2; + GLint _arg3; + GLint _arg4; + GLsizei _arg5; + GLint _arg6; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiii:glCopyTexImage1D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCopyTexImage1D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCopyTexImage2D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLenum _arg2; + GLint _arg3; + GLint _arg4; + GLsizei _arg5; + GLsizei _arg6; + GLint _arg7; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiiii:glCopyTexImage2D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCopyTexImage2D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCopyTexSubImage1D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + GLint _arg4; + GLsizei _arg5; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiii:glCopyTexSubImage1D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCopyTexSubImage1D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCopyTexSubImage2D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + GLint _arg4; + GLint _arg5; + GLsizei _arg6; + GLsizei _arg7; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiiii:glCopyTexSubImage2D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCopyTexSubImage2D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glCullFace(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glCullFace",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glCullFace(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDeleteLists(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + GLsizei _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glDeleteLists",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDeleteLists(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDeleteTextures(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLuint * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glDeleteTextures",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glDeleteTextures. Expected _GLuint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glDeleteTextures(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDepthFunc(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glDepthFunc",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDepthFunc(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDepthMask(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"b:glDepthMask",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDepthMask(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDepthRange(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLclampd _arg0; + GLclampd _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"dd:glDepthRange",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDepthRange(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDisable(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glDisable",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDisable(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDisableClientState(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glDisableClientState",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDisableClientState(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDrawArrays(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLsizei _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glDrawArrays",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDrawArrays(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDrawBuffer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glDrawBuffer",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glDrawBuffer(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDrawElements(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLenum _arg2; + GLvoid * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glDrawElements",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glDrawElements. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glDrawElements(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glDrawPixels(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLsizei _arg1; + GLenum _arg2; + GLenum _arg3; + GLvoid * _arg4; + char * _argc4 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiis:glDrawPixels",&_arg0,&_arg1,&_arg2,&_arg3,&_argc4)) + return NULL; + if (_argc4) { + if (SWIG_GetPtr(_argc4,(void **) &_arg4,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of glDrawPixels. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glDrawPixels(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEdgeFlag(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"b:glEdgeFlag",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEdgeFlag(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEdgeFlagPointer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLvoid * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glEdgeFlagPointer",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glEdgeFlagPointer. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glEdgeFlagPointer(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEdgeFlagv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glEdgeFlagv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLboolean_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glEdgeFlagv. Expected _GLboolean_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glEdgeFlagv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEnable(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glEnable",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEnable(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEnableClientState(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glEnableClientState",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEnableClientState(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEnd(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glEnd")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEnd(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEndList(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glEndList")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEndList(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord1d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"d:glEvalCoord1d",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord1d(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord1dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glEvalCoord1dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glEvalCoord1dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord1dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord1f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"f:glEvalCoord1f",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord1f(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord1fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glEvalCoord1fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glEvalCoord1fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord1fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord2d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"dd:glEvalCoord2d",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord2d(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord2dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glEvalCoord2dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glEvalCoord2dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord2dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord2f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ff:glEvalCoord2f",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord2f(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalCoord2fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glEvalCoord2fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glEvalCoord2fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalCoord2fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalMesh1(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glEvalMesh1",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalMesh1(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalMesh2(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + GLint _arg4; + + self = self; + if(!PyArg_ParseTuple(args,"iiiii:glEvalMesh2",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalMesh2(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalPoint1(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glEvalPoint1",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalPoint1(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glEvalPoint2(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glEvalPoint2",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glEvalPoint2(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFeedbackBuffer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glFeedbackBuffer",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glFeedbackBuffer. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glFeedbackBuffer(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFinish(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glFinish")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glFinish(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFlush(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glFlush")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glFlush(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFogf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"if:glFogf",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glFogf(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFogfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glFogfv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glFogfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glFogfv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFogi(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glFogi",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glFogi(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFogiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glFogiv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glFogiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glFogiv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFrontFace(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glFrontFace",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glFrontFace(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glFrustum(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + GLdouble _arg4; + GLdouble _arg5; + + self = self; + if(!PyArg_ParseTuple(args,"dddddd:glFrustum",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glFrustum(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGenLists(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _result; + GLsizei _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glGenLists",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLuint )glGenLists(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_glGenTextures(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLuint * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGenTextures",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGenTextures. Expected _GLuint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGenTextures(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetBooleanv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLboolean * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetBooleanv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLboolean_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetBooleanv. Expected _GLboolean_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetBooleanv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetClipPlane(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLdouble * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetClipPlane",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetClipPlane. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetClipPlane(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetDoublev(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLdouble * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetDoublev",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetDoublev. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetDoublev(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetError(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _result; + + self = self; + if(!PyArg_ParseTuple(args,":glGetError")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLenum )glGetError(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_glGetFloatv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetFloatv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetFloatv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetFloatv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetIntegerv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetIntegerv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetIntegerv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetIntegerv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetLightfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetLightfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetLightfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetLightfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetLightiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetLightiv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetLightiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetLightiv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetMapdv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLdouble * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetMapdv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetMapdv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetMapdv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetMapfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetMapfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetMapfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetMapfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetMapiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetMapiv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetMapiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetMapiv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetMaterialfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetMaterialfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetMaterialfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetMaterialfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetMaterialiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetMaterialiv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetMaterialiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetMaterialiv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetPixelMapfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetPixelMapfv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetPixelMapfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetPixelMapfv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetPixelMapuiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLuint * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetPixelMapuiv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetPixelMapuiv. Expected _GLuint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetPixelMapuiv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetPixelMapusv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLushort * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetPixelMapusv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLushort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetPixelMapusv. Expected _GLushort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetPixelMapusv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetPointerv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLvoid ** _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glGetPointerv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glGetPointerv. Expected _GLvoid_pp."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetPointerv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetPolygonStipple(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glGetPolygonStipple",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLubyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glGetPolygonStipple. Expected _GLubyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetPolygonStipple(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetString(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte * _result; + GLenum _arg0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"i:glGetString",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLubyte *)glGetString(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_GLubyte_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static PyObject *_wrap_glGetTexEnvfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetTexEnvfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetTexEnvfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexEnvfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexEnviv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetTexEnviv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetTexEnviv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexEnviv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexGendv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLdouble * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetTexGendv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetTexGendv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexGendv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexGenfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetTexGenfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetTexGenfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexGenfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexGeniv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetTexGeniv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetTexGeniv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexGeniv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexImage(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLenum _arg2; + GLenum _arg3; + GLvoid * _arg4; + char * _argc4 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiis:glGetTexImage",&_arg0,&_arg1,&_arg2,&_arg3,&_argc4)) + return NULL; + if (_argc4) { + if (SWIG_GetPtr(_argc4,(void **) &_arg4,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of glGetTexImage. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexImage(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexLevelParameterfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLenum _arg2; + GLfloat * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glGetTexLevelParameterfv",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glGetTexLevelParameterfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexLevelParameterfv(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexLevelParameteriv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLenum _arg2; + GLint * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glGetTexLevelParameteriv",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glGetTexLevelParameteriv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexLevelParameteriv(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexParameterfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetTexParameterfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetTexParameterfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexParameterfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glGetTexParameteriv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glGetTexParameteriv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glGetTexParameteriv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glGetTexParameteriv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glHint(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glHint",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glHint(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexMask(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glIndexMask",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexMask(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexPointer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLvoid * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glIndexPointer",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glIndexPointer. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexPointer(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexd(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"d:glIndexd",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexd(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexdv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glIndexdv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glIndexdv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexdv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"f:glIndexf",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexf(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glIndexfv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glIndexfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexfv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexi(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glIndexi",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexi(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glIndexiv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glIndexiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexiv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexs(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"h:glIndexs",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexs(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexsv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glIndexsv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glIndexsv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexsv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexub(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"b:glIndexub",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexub(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIndexubv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glIndexubv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLubyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glIndexubv. Expected _GLubyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glIndexubv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glInitNames(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glInitNames")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glInitNames(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glInterleavedArrays(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLvoid * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glInterleavedArrays",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glInterleavedArrays. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glInterleavedArrays(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glIsEnabled(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean _result; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glIsEnabled",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLboolean )glIsEnabled(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +static PyObject *_wrap_glIsList(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean _result; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glIsList",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLboolean )glIsList(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +static PyObject *_wrap_glIsTexture(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLboolean _result; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glIsTexture",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLboolean )glIsTexture(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +static PyObject *_wrap_glLightModelf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"if:glLightModelf",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLightModelf(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLightModelfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glLightModelfv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glLightModelfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glLightModelfv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLightModeli(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glLightModeli",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLightModeli(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLightModeliv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glLightModeliv",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glLightModeliv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glLightModeliv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLightf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iif:glLightf",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLightf(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLightfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glLightfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glLightfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glLightfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLighti(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glLighti",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLighti(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLightiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glLightiv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glLightiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glLightiv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLineStipple(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLushort _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ih:glLineStipple",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLineStipple(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLineWidth(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"f:glLineWidth",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLineWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glListBase(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glListBase",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glListBase(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLoadIdentity(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glLoadIdentity")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLoadIdentity(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLoadMatrixd(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glLoadMatrixd",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glLoadMatrixd. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glLoadMatrixd(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLoadMatrixf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glLoadMatrixf",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glLoadMatrixf. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glLoadMatrixf(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLoadName(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glLoadName",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLoadName(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glLogicOp(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glLogicOp",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glLogicOp(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMap1d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLint _arg3; + GLint _arg4; + GLdouble * _arg5; + char * _argc5 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iddiis:glMap1d",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_argc5)) + return NULL; + if (_argc5) { + if (SWIG_GetPtr(_argc5,(void **) &_arg5,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of glMap1d. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMap1d(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMap1f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLint _arg3; + GLint _arg4; + GLfloat * _arg5; + char * _argc5 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iffiis:glMap1f",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_argc5)) + return NULL; + if (_argc5) { + if (SWIG_GetPtr(_argc5,(void **) &_arg5,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of glMap1f. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMap1f(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMap2d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLint _arg3; + GLint _arg4; + GLdouble _arg5; + GLdouble _arg6; + GLint _arg7; + GLint _arg8; + GLdouble * _arg9; + char * _argc9 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iddiiddiis:glMap2d",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7,&_arg8,&_argc9)) + return NULL; + if (_argc9) { + if (SWIG_GetPtr(_argc9,(void **) &_arg9,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 10 of glMap2d. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMap2d(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMap2f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLint _arg3; + GLint _arg4; + GLfloat _arg5; + GLfloat _arg6; + GLint _arg7; + GLint _arg8; + GLfloat * _arg9; + char * _argc9 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iffiiffiis:glMap2f",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7,&_arg8,&_argc9)) + return NULL; + if (_argc9) { + if (SWIG_GetPtr(_argc9,(void **) &_arg9,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 10 of glMap2f. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMap2f(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMapGrid1d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"idd:glMapGrid1d",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glMapGrid1d(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMapGrid1f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iff:glMapGrid1f",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glMapGrid1f(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMapGrid2d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLint _arg3; + GLdouble _arg4; + GLdouble _arg5; + + self = self; + if(!PyArg_ParseTuple(args,"iddidd:glMapGrid2d",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glMapGrid2d(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMapGrid2f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLint _arg3; + GLfloat _arg4; + GLfloat _arg5; + + self = self; + if(!PyArg_ParseTuple(args,"iffiff:glMapGrid2f",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glMapGrid2f(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMaterialf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iif:glMaterialf",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glMaterialf(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMaterialfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glMaterialfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glMaterialfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMaterialfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMateriali(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glMateriali",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glMateriali(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMaterialiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glMaterialiv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glMaterialiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMaterialiv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMatrixMode(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glMatrixMode",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glMatrixMode(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMultMatrixd(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glMultMatrixd",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glMultMatrixd. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMultMatrixd(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glMultMatrixf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glMultMatrixf",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glMultMatrixf. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glMultMatrixf(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNewList(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + GLenum _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glNewList",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glNewList(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3b(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbyte _arg0; + GLbyte _arg1; + GLbyte _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"bbb:glNormal3b",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3b(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3bv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glNormal3bv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLbyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glNormal3bv. Expected _GLbyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3bv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"ddd:glNormal3d",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3d(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glNormal3dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glNormal3dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"fff:glNormal3f",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3f(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glNormal3fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glNormal3fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glNormal3i",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3i(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glNormal3iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glNormal3iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"hhh:glNormal3s",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3s(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormal3sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glNormal3sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glNormal3sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormal3sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glNormalPointer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLvoid * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glNormalPointer",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glNormalPointer. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glNormalPointer(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glOrtho(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + GLdouble _arg4; + GLdouble _arg5; + + self = self; + if(!PyArg_ParseTuple(args,"dddddd:glOrtho",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glOrtho(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPassThrough(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"f:glPassThrough",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPassThrough(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelMapfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glPixelMapfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glPixelMapfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelMapfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelMapuiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLuint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glPixelMapuiv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glPixelMapuiv. Expected _GLuint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelMapuiv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelMapusv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLsizei _arg1; + GLushort * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glPixelMapusv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLushort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glPixelMapusv. Expected _GLushort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelMapusv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelStoref(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"if:glPixelStoref",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelStoref(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelStorei(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glPixelStorei",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelStorei(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelTransferf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"if:glPixelTransferf",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelTransferf(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelTransferi(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glPixelTransferi",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelTransferi(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPixelZoom(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ff:glPixelZoom",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPixelZoom(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPointSize(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"f:glPointSize",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPointSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPolygonMode(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glPolygonMode",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPolygonMode(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPolygonOffset(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ff:glPolygonOffset",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPolygonOffset(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPolygonStipple(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLubyte * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glPolygonStipple",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLubyte_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glPolygonStipple. Expected _GLubyte_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glPolygonStipple(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPopAttrib(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glPopAttrib")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPopAttrib(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPopClientAttrib(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glPopClientAttrib")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPopClientAttrib(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPopMatrix(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glPopMatrix")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPopMatrix(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPopName(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glPopName")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPopName(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPrioritizeTextures(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLuint * _arg1; + GLclampf * _arg2; + char * _argc1 = 0; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iss:glPrioritizeTextures",&_arg0,&_argc1,&_argc2)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glPrioritizeTextures. Expected _GLuint_p."); + return NULL; + } + } + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLclampf_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glPrioritizeTextures. Expected _GLclampf_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glPrioritizeTextures(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPushAttrib(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbitfield _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glPushAttrib",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPushAttrib(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPushClientAttrib(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLbitfield _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glPushClientAttrib",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPushClientAttrib(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPushMatrix(PyObject *self, PyObject *args) { + PyObject * _resultobj; + + self = self; + if(!PyArg_ParseTuple(args,":glPushMatrix")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPushMatrix(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glPushName(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glPushName",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glPushName(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"dd:glRasterPos2d",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2d(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos2dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos2dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ff:glRasterPos2f",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2f(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos2fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos2fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glRasterPos2i",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2i(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos2iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos2iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"hh:glRasterPos2s",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2s(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos2sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos2sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos2sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos2sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"ddd:glRasterPos3d",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3d(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos3dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos3dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"fff:glRasterPos3f",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3f(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos3fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos3fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glRasterPos3i",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3i(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos3iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos3iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"hhh:glRasterPos3s",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3s(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos3sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos3sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos3sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos3sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"dddd:glRasterPos4d",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4d(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos4dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos4dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLfloat _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glRasterPos4f",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4f(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos4fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos4fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glRasterPos4i",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4i(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos4iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos4iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + GLshort _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"hhhh:glRasterPos4s",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4s(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRasterPos4sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glRasterPos4sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRasterPos4sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRasterPos4sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glReadBuffer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glReadBuffer",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glReadBuffer(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glReadPixels(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLsizei _arg2; + GLsizei _arg3; + GLenum _arg4; + GLenum _arg5; + GLvoid * _arg6; + char * _argc6 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiis:glReadPixels",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_argc6)) + return NULL; + if (_argc6) { + if (SWIG_GetPtr(_argc6,(void **) &_arg6,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of glReadPixels. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glReadPixels(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRectd(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"dddd:glRectd",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRectd(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRectdv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + GLdouble * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:glRectdv",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRectdv. Expected _GLdouble_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glRectdv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRectdv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRectf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLfloat _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glRectf",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRectf(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRectfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + GLfloat * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:glRectfv",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRectfv. Expected _GLfloat_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glRectfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRectfv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRecti(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glRecti",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRecti(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRectiv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + GLint * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:glRectiv",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRectiv. Expected _GLint_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glRectiv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRectiv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRects(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + GLshort _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"hhhh:glRects",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRects(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRectsv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + GLshort * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:glRectsv",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glRectsv. Expected _GLshort_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glRectsv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glRectsv(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRenderMode(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _result; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glRenderMode",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (GLint )glRenderMode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_glRotated(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"dddd:glRotated",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRotated(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glRotatef(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLfloat _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glRotatef",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glRotatef(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glScaled(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"ddd:glScaled",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glScaled(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glScalef(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"fff:glScalef",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glScalef(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glScissor(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLsizei _arg2; + GLsizei _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glScissor",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glScissor(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glSelectBuffer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLsizei _arg0; + GLuint * _arg1; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"is:glSelectBuffer",&_arg0,&_argc1)) + return NULL; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_GLuint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of glSelectBuffer. Expected _GLuint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glSelectBuffer(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glShadeModel(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glShadeModel",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glShadeModel(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glStencilFunc(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLuint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glStencilFunc",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glStencilFunc(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glStencilMask(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLuint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glStencilMask",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glStencilMask(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glStencilOp(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLenum _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glStencilOp",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glStencilOp(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"d:glTexCoord1d",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1d(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord1dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord1dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"f:glTexCoord1f",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1f(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord1fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord1fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"i:glTexCoord1i",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1i(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord1iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord1iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"h:glTexCoord1s",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1s(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord1sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord1sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord1sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord1sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"dd:glTexCoord2d",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2d(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord2dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord2dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ff:glTexCoord2f",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2f(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord2fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord2fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glTexCoord2i",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2i(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord2iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord2iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"hh:glTexCoord2s",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2s(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord2sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord2sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord2sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord2sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"ddd:glTexCoord3d",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3d(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord3dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord3dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"fff:glTexCoord3f",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3f(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord3fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord3fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glTexCoord3i",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3i(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord3iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord3iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"hhh:glTexCoord3s",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3s(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord3sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord3sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord3sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord3sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"dddd:glTexCoord4d",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4d(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord4dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord4dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLfloat _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glTexCoord4f",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4f(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord4fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord4fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glTexCoord4i",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4i(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord4iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord4iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + GLshort _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"hhhh:glTexCoord4s",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4s(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoord4sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glTexCoord4sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glTexCoord4sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoord4sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexCoordPointer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLenum _arg1; + GLsizei _arg2; + GLvoid * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glTexCoordPointer",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glTexCoordPointer. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexCoordPointer(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexEnvf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iif:glTexEnvf",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexEnvf(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexEnvfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glTexEnvfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glTexEnvfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexEnvfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexEnvi(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glTexEnvi",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexEnvi(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexEnviv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glTexEnviv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glTexEnviv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexEnviv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexGend(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iid:glTexGend",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexGend(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexGendv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLdouble * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glTexGendv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glTexGendv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexGendv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexGenf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iif:glTexGenf",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexGenf(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexGenfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glTexGenfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glTexGenfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexGenfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexGeni(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glTexGeni",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexGeni(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexGeniv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glTexGeniv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glTexGeniv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexGeniv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexImage1D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + GLsizei _arg3; + GLint _arg4; + GLenum _arg5; + GLenum _arg6; + GLvoid * _arg7; + char * _argc7 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiiis:glTexImage1D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_argc7)) + return NULL; + if (_argc7) { + if (SWIG_GetPtr(_argc7,(void **) &_arg7,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 8 of glTexImage1D. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexImage1D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexImage2D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + GLsizei _arg3; + GLsizei _arg4; + GLint _arg5; + GLenum _arg6; + GLenum _arg7; + GLvoid * _arg8; + char * _argc8 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiiiis:glTexImage2D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7,&_argc8)) + return NULL; + if (_argc8) { + if (SWIG_GetPtr(_argc8,(void **) &_arg8,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 9 of glTexImage2D. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexImage2D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexParameterf(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iif:glTexParameterf",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexParameterf(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexParameterfv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLfloat * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glTexParameterfv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glTexParameterfv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexParameterfv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexParameteri(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glTexParameteri",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexParameteri(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexParameteriv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLenum _arg1; + GLint * _arg2; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iis:glTexParameteriv",&_arg0,&_arg1,&_argc2)) + return NULL; + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of glTexParameteriv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexParameteriv(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexSubImage1D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + GLsizei _arg3; + GLenum _arg4; + GLenum _arg5; + GLvoid * _arg6; + char * _argc6 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiis:glTexSubImage1D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_argc6)) + return NULL; + if (_argc6) { + if (SWIG_GetPtr(_argc6,(void **) &_arg6,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of glTexSubImage1D. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexSubImage1D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTexSubImage2D(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLenum _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + GLsizei _arg4; + GLsizei _arg5; + GLenum _arg6; + GLenum _arg7; + GLvoid * _arg8; + char * _argc8 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiiiiiiis:glTexSubImage2D",&_arg0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7,&_argc8)) + return NULL; + if (_argc8) { + if (SWIG_GetPtr(_argc8,(void **) &_arg8,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 9 of glTexSubImage2D. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glTexSubImage2D(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTranslated(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"ddd:glTranslated",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTranslated(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glTranslatef(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"fff:glTranslatef",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glTranslatef(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"dd:glVertex2d",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2d(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex2dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex2dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ff:glVertex2f",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2f(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex2fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex2fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"ii:glVertex2i",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2i(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex2iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex2iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + + self = self; + if(!PyArg_ParseTuple(args,"hh:glVertex2s",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2s(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex2sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex2sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex2sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex2sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"ddd:glVertex3d",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3d(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex3dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex3dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"fff:glVertex3f",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3f(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex3fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex3fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"iii:glVertex3i",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3i(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex3iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex3iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + + self = self; + if(!PyArg_ParseTuple(args,"hhh:glVertex3s",&_arg0,&_arg1,&_arg2)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3s(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex3sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex3sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex3sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex3sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4d(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble _arg0; + GLdouble _arg1; + GLdouble _arg2; + GLdouble _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"dddd:glVertex4d",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4d(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4dv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLdouble * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex4dv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLdouble_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex4dv. Expected _GLdouble_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4dv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4f(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat _arg0; + GLfloat _arg1; + GLfloat _arg2; + GLfloat _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"ffff:glVertex4f",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4f(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4fv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLfloat * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex4fv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLfloat_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex4fv. Expected _GLfloat_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4fv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4i(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLint _arg2; + GLint _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glVertex4i",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4i(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4iv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex4iv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex4iv. Expected _GLint_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4iv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4s(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort _arg0; + GLshort _arg1; + GLshort _arg2; + GLshort _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"hhhh:glVertex4s",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4s(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertex4sv(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLshort * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:glVertex4sv",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_GLshort_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of glVertex4sv. Expected _GLshort_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertex4sv(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glVertexPointer(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLenum _arg1; + GLsizei _arg2; + GLvoid * _arg3; + char * _argc3 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"iiis:glVertexPointer",&_arg0,&_arg1,&_arg2,&_argc3)) + return NULL; + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,(char *) 0 )) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of glVertexPointer. Expected _GLvoid_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + glVertexPointer(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_glViewport(PyObject *self, PyObject *args) { + PyObject * _resultobj; + GLint _arg0; + GLint _arg1; + GLsizei _arg2; + GLsizei _arg3; + + self = self; + if(!PyArg_ParseTuple(args,"iiii:glViewport",&_arg0,&_arg1,&_arg2,&_arg3)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + glViewport(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define new_wxGLContext(_swigarg0,_swigarg1,_swigarg2) (new wxGLContext(_swigarg0,_swigarg1,_swigarg2)) +static PyObject *_wrap_new_wxGLContext(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _result; + bool _arg0; + wxWindow * _arg1; + wxPalette * _arg2 = &wxNullPalette; + int tempbool0; + char * _argc1 = 0; + char * _argc2 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"is|s:new_wxGLContext",&tempbool0,&_argc1,&_argc2)) + return NULL; + _arg0 = (bool ) tempbool0; + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxGLContext. Expected _wxWindow_p."); + return NULL; + } + } + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_wxPalette_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGLContext. Expected _wxPalette_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGLContext *)new_wxGLContext(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLContext_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define delete_wxGLContext(_swigobj) (delete _swigobj) +static PyObject *_wrap_delete_wxGLContext(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:delete_wxGLContext",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxGLContext. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxGLContext(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLContext_SetCurrent(_swigobj) (_swigobj->SetCurrent()) +static PyObject *_wrap_wxGLContext_SetCurrent(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLContext_SetCurrent",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetCurrent. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLContext_SetCurrent(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLContext_SetColour(_swigobj,_swigarg0) (_swigobj->SetColour(_swigarg0)) +static PyObject *_wrap_wxGLContext_SetColour(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _arg0; + char * _arg1; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxGLContext_SetColour",&_argc0,&_arg1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetColour. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLContext_SetColour(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLContext_SwapBuffers(_swigobj) (_swigobj->SwapBuffers()) +static PyObject *_wrap_wxGLContext_SwapBuffers(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLContext_SwapBuffers",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SwapBuffers. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLContext_SwapBuffers(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLContext_SetupPixelFormat(_swigobj) (_swigobj->SetupPixelFormat()) +static PyObject *_wrap_wxGLContext_SetupPixelFormat(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLContext_SetupPixelFormat",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetupPixelFormat. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLContext_SetupPixelFormat(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLContext_SetupPalette(_swigobj,_swigarg0) (_swigobj->SetupPalette(_swigarg0)) +static PyObject *_wrap_wxGLContext_SetupPalette(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _arg0; + wxPalette * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxGLContext_SetupPalette",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetupPalette. Expected _wxGLContext_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPalette_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGLContext_SetupPalette. Expected _wxPalette_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLContext_SetupPalette(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLContext_CreateDefaultPalette(_swigobj) (_swigobj->CreateDefaultPalette()) +static PyObject *_wrap_wxGLContext_CreateDefaultPalette(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPalette * _result; + wxGLContext * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLContext_CreateDefaultPalette",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_CreateDefaultPalette. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPalette (wxGLContext_CreateDefaultPalette(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPalette_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxGLContext_GetPalette(_swigobj) (_swigobj->GetPalette()) +static PyObject *_wrap_wxGLContext_GetPalette(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPalette * _result; + wxGLContext * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLContext_GetPalette",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_GetPalette. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPalette *)wxGLContext_GetPalette(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPalette_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxGLContext_GetWindow(_swigobj) (_swigobj->GetWindow()) +static PyObject *_wrap_wxGLContext_GetWindow(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxWindow * _result; + wxGLContext * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLContext_GetWindow",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_GetWindow. Expected _wxGLContext_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxGLContext_GetWindow(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static void *SwigwxGLCanvasTowxScrolledWindow(void *ptr) { + wxGLCanvas *src; + wxScrolledWindow *dest; + src = (wxGLCanvas *) ptr; + dest = (wxScrolledWindow *) src; + return (void *) dest; +} + +static void *SwigwxGLCanvasTowxWindow(void *ptr) { + wxGLCanvas *src; + wxWindow *dest; + src = (wxGLCanvas *) ptr; + dest = (wxWindow *) src; + return (void *) dest; +} + +static void *SwigwxGLCanvasTowxEvtHandler(void *ptr) { + wxGLCanvas *src; + wxEvtHandler *dest; + src = (wxGLCanvas *) ptr; + dest = (wxEvtHandler *) src; + return (void *) dest; +} + +#define new_wxGLCanvas(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7) (new wxGLCanvas(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7)) +static PyObject *_wrap_new_wxGLCanvas(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLCanvas * _result; + wxWindow * _arg0; + wxWindowID _arg1 = -1; + wxPoint * _arg2 = &wxPyDefaultPosition; + wxSize * _arg3 = &wxPyDefaultSize; + long _arg4 = 0; + char * _arg5 = "GLCanvas"; + int * _arg6 = 0; + wxPalette * _arg7 = &wxNullPalette; + char * _argc0 = 0; + char * _argc2 = 0; + char * _argc3 = 0; + char * _argc6 = 0; + char * _argc7 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s|isslsss:new_wxGLCanvas",&_argc0,&_arg1,&_argc2,&_argc3,&_arg4,&_arg5,&_argc6,&_argc7)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGLCanvas. Expected _wxWindow_p."); + return NULL; + } + } + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_wxPoint_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGLCanvas. Expected _wxPoint_p."); + return NULL; + } + } + if (_argc3) { + if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxSize_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxGLCanvas. Expected _wxSize_p."); + return NULL; + } + } + if (_argc6) { + if (SWIG_GetPtr(_argc6,(void **) &_arg6,"_int_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of new_wxGLCanvas. Expected _int_p."); + return NULL; + } + } + if (_argc7) { + if (SWIG_GetPtr(_argc7,(void **) &_arg7,"_wxPalette_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 8 of new_wxGLCanvas. Expected _wxPalette_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGLCanvas *)new_wxGLCanvas(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLCanvas_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxGLCanvas_SetCurrent(_swigobj) (_swigobj->SetCurrent()) +static PyObject *_wrap_wxGLCanvas_SetCurrent(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLCanvas * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLCanvas_SetCurrent",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLCanvas_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SetCurrent. Expected _wxGLCanvas_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLCanvas_SetCurrent(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLCanvas_SetColour(_swigobj,_swigarg0) (_swigobj->SetColour(_swigarg0)) +static PyObject *_wrap_wxGLCanvas_SetColour(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLCanvas * _arg0; + char * _arg1; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxGLCanvas_SetColour",&_argc0,&_arg1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLCanvas_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SetColour. Expected _wxGLCanvas_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLCanvas_SetColour(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLCanvas_SwapBuffers(_swigobj) (_swigobj->SwapBuffers()) +static PyObject *_wrap_wxGLCanvas_SwapBuffers(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLCanvas * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLCanvas_SwapBuffers",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLCanvas_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SwapBuffers. Expected _wxGLCanvas_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGLCanvas_SwapBuffers(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxGLCanvas_GetContext(_swigobj) (_swigobj->GetContext()) +static PyObject *_wrap_wxGLCanvas_GetContext(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGLContext * _result; + wxGLCanvas * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxGLCanvas_GetContext",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLCanvas_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_GetContext. Expected _wxGLCanvas_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGLContext *)wxGLCanvas_GetContext(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLContext_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static PyMethodDef glcanvascMethods[] = { + { "wxGLCanvas_GetContext", _wrap_wxGLCanvas_GetContext, 1 }, + { "wxGLCanvas_SwapBuffers", _wrap_wxGLCanvas_SwapBuffers, 1 }, + { "wxGLCanvas_SetColour", _wrap_wxGLCanvas_SetColour, 1 }, + { "wxGLCanvas_SetCurrent", _wrap_wxGLCanvas_SetCurrent, 1 }, + { "new_wxGLCanvas", _wrap_new_wxGLCanvas, 1 }, + { "wxGLContext_GetWindow", _wrap_wxGLContext_GetWindow, 1 }, + { "wxGLContext_GetPalette", _wrap_wxGLContext_GetPalette, 1 }, + { "wxGLContext_CreateDefaultPalette", _wrap_wxGLContext_CreateDefaultPalette, 1 }, + { "wxGLContext_SetupPalette", _wrap_wxGLContext_SetupPalette, 1 }, + { "wxGLContext_SetupPixelFormat", _wrap_wxGLContext_SetupPixelFormat, 1 }, + { "wxGLContext_SwapBuffers", _wrap_wxGLContext_SwapBuffers, 1 }, + { "wxGLContext_SetColour", _wrap_wxGLContext_SetColour, 1 }, + { "wxGLContext_SetCurrent", _wrap_wxGLContext_SetCurrent, 1 }, + { "delete_wxGLContext", _wrap_delete_wxGLContext, 1 }, + { "new_wxGLContext", _wrap_new_wxGLContext, 1 }, + { "glViewport", _wrap_glViewport, 1 }, + { "glVertexPointer", _wrap_glVertexPointer, 1 }, + { "glVertex4sv", _wrap_glVertex4sv, 1 }, + { "glVertex4s", _wrap_glVertex4s, 1 }, + { "glVertex4iv", _wrap_glVertex4iv, 1 }, + { "glVertex4i", _wrap_glVertex4i, 1 }, + { "glVertex4fv", _wrap_glVertex4fv, 1 }, + { "glVertex4f", _wrap_glVertex4f, 1 }, + { "glVertex4dv", _wrap_glVertex4dv, 1 }, + { "glVertex4d", _wrap_glVertex4d, 1 }, + { "glVertex3sv", _wrap_glVertex3sv, 1 }, + { "glVertex3s", _wrap_glVertex3s, 1 }, + { "glVertex3iv", _wrap_glVertex3iv, 1 }, + { "glVertex3i", _wrap_glVertex3i, 1 }, + { "glVertex3fv", _wrap_glVertex3fv, 1 }, + { "glVertex3f", _wrap_glVertex3f, 1 }, + { "glVertex3dv", _wrap_glVertex3dv, 1 }, + { "glVertex3d", _wrap_glVertex3d, 1 }, + { "glVertex2sv", _wrap_glVertex2sv, 1 }, + { "glVertex2s", _wrap_glVertex2s, 1 }, + { "glVertex2iv", _wrap_glVertex2iv, 1 }, + { "glVertex2i", _wrap_glVertex2i, 1 }, + { "glVertex2fv", _wrap_glVertex2fv, 1 }, + { "glVertex2f", _wrap_glVertex2f, 1 }, + { "glVertex2dv", _wrap_glVertex2dv, 1 }, + { "glVertex2d", _wrap_glVertex2d, 1 }, + { "glTranslatef", _wrap_glTranslatef, 1 }, + { "glTranslated", _wrap_glTranslated, 1 }, + { "glTexSubImage2D", _wrap_glTexSubImage2D, 1 }, + { "glTexSubImage1D", _wrap_glTexSubImage1D, 1 }, + { "glTexParameteriv", _wrap_glTexParameteriv, 1 }, + { "glTexParameteri", _wrap_glTexParameteri, 1 }, + { "glTexParameterfv", _wrap_glTexParameterfv, 1 }, + { "glTexParameterf", _wrap_glTexParameterf, 1 }, + { "glTexImage2D", _wrap_glTexImage2D, 1 }, + { "glTexImage1D", _wrap_glTexImage1D, 1 }, + { "glTexGeniv", _wrap_glTexGeniv, 1 }, + { "glTexGeni", _wrap_glTexGeni, 1 }, + { "glTexGenfv", _wrap_glTexGenfv, 1 }, + { "glTexGenf", _wrap_glTexGenf, 1 }, + { "glTexGendv", _wrap_glTexGendv, 1 }, + { "glTexGend", _wrap_glTexGend, 1 }, + { "glTexEnviv", _wrap_glTexEnviv, 1 }, + { "glTexEnvi", _wrap_glTexEnvi, 1 }, + { "glTexEnvfv", _wrap_glTexEnvfv, 1 }, + { "glTexEnvf", _wrap_glTexEnvf, 1 }, + { "glTexCoordPointer", _wrap_glTexCoordPointer, 1 }, + { "glTexCoord4sv", _wrap_glTexCoord4sv, 1 }, + { "glTexCoord4s", _wrap_glTexCoord4s, 1 }, + { "glTexCoord4iv", _wrap_glTexCoord4iv, 1 }, + { "glTexCoord4i", _wrap_glTexCoord4i, 1 }, + { "glTexCoord4fv", _wrap_glTexCoord4fv, 1 }, + { "glTexCoord4f", _wrap_glTexCoord4f, 1 }, + { "glTexCoord4dv", _wrap_glTexCoord4dv, 1 }, + { "glTexCoord4d", _wrap_glTexCoord4d, 1 }, + { "glTexCoord3sv", _wrap_glTexCoord3sv, 1 }, + { "glTexCoord3s", _wrap_glTexCoord3s, 1 }, + { "glTexCoord3iv", _wrap_glTexCoord3iv, 1 }, + { "glTexCoord3i", _wrap_glTexCoord3i, 1 }, + { "glTexCoord3fv", _wrap_glTexCoord3fv, 1 }, + { "glTexCoord3f", _wrap_glTexCoord3f, 1 }, + { "glTexCoord3dv", _wrap_glTexCoord3dv, 1 }, + { "glTexCoord3d", _wrap_glTexCoord3d, 1 }, + { "glTexCoord2sv", _wrap_glTexCoord2sv, 1 }, + { "glTexCoord2s", _wrap_glTexCoord2s, 1 }, + { "glTexCoord2iv", _wrap_glTexCoord2iv, 1 }, + { "glTexCoord2i", _wrap_glTexCoord2i, 1 }, + { "glTexCoord2fv", _wrap_glTexCoord2fv, 1 }, + { "glTexCoord2f", _wrap_glTexCoord2f, 1 }, + { "glTexCoord2dv", _wrap_glTexCoord2dv, 1 }, + { "glTexCoord2d", _wrap_glTexCoord2d, 1 }, + { "glTexCoord1sv", _wrap_glTexCoord1sv, 1 }, + { "glTexCoord1s", _wrap_glTexCoord1s, 1 }, + { "glTexCoord1iv", _wrap_glTexCoord1iv, 1 }, + { "glTexCoord1i", _wrap_glTexCoord1i, 1 }, + { "glTexCoord1fv", _wrap_glTexCoord1fv, 1 }, + { "glTexCoord1f", _wrap_glTexCoord1f, 1 }, + { "glTexCoord1dv", _wrap_glTexCoord1dv, 1 }, + { "glTexCoord1d", _wrap_glTexCoord1d, 1 }, + { "glStencilOp", _wrap_glStencilOp, 1 }, + { "glStencilMask", _wrap_glStencilMask, 1 }, + { "glStencilFunc", _wrap_glStencilFunc, 1 }, + { "glShadeModel", _wrap_glShadeModel, 1 }, + { "glSelectBuffer", _wrap_glSelectBuffer, 1 }, + { "glScissor", _wrap_glScissor, 1 }, + { "glScalef", _wrap_glScalef, 1 }, + { "glScaled", _wrap_glScaled, 1 }, + { "glRotatef", _wrap_glRotatef, 1 }, + { "glRotated", _wrap_glRotated, 1 }, + { "glRenderMode", _wrap_glRenderMode, 1 }, + { "glRectsv", _wrap_glRectsv, 1 }, + { "glRects", _wrap_glRects, 1 }, + { "glRectiv", _wrap_glRectiv, 1 }, + { "glRecti", _wrap_glRecti, 1 }, + { "glRectfv", _wrap_glRectfv, 1 }, + { "glRectf", _wrap_glRectf, 1 }, + { "glRectdv", _wrap_glRectdv, 1 }, + { "glRectd", _wrap_glRectd, 1 }, + { "glReadPixels", _wrap_glReadPixels, 1 }, + { "glReadBuffer", _wrap_glReadBuffer, 1 }, + { "glRasterPos4sv", _wrap_glRasterPos4sv, 1 }, + { "glRasterPos4s", _wrap_glRasterPos4s, 1 }, + { "glRasterPos4iv", _wrap_glRasterPos4iv, 1 }, + { "glRasterPos4i", _wrap_glRasterPos4i, 1 }, + { "glRasterPos4fv", _wrap_glRasterPos4fv, 1 }, + { "glRasterPos4f", _wrap_glRasterPos4f, 1 }, + { "glRasterPos4dv", _wrap_glRasterPos4dv, 1 }, + { "glRasterPos4d", _wrap_glRasterPos4d, 1 }, + { "glRasterPos3sv", _wrap_glRasterPos3sv, 1 }, + { "glRasterPos3s", _wrap_glRasterPos3s, 1 }, + { "glRasterPos3iv", _wrap_glRasterPos3iv, 1 }, + { "glRasterPos3i", _wrap_glRasterPos3i, 1 }, + { "glRasterPos3fv", _wrap_glRasterPos3fv, 1 }, + { "glRasterPos3f", _wrap_glRasterPos3f, 1 }, + { "glRasterPos3dv", _wrap_glRasterPos3dv, 1 }, + { "glRasterPos3d", _wrap_glRasterPos3d, 1 }, + { "glRasterPos2sv", _wrap_glRasterPos2sv, 1 }, + { "glRasterPos2s", _wrap_glRasterPos2s, 1 }, + { "glRasterPos2iv", _wrap_glRasterPos2iv, 1 }, + { "glRasterPos2i", _wrap_glRasterPos2i, 1 }, + { "glRasterPos2fv", _wrap_glRasterPos2fv, 1 }, + { "glRasterPos2f", _wrap_glRasterPos2f, 1 }, + { "glRasterPos2dv", _wrap_glRasterPos2dv, 1 }, + { "glRasterPos2d", _wrap_glRasterPos2d, 1 }, + { "glPushName", _wrap_glPushName, 1 }, + { "glPushMatrix", _wrap_glPushMatrix, 1 }, + { "glPushClientAttrib", _wrap_glPushClientAttrib, 1 }, + { "glPushAttrib", _wrap_glPushAttrib, 1 }, + { "glPrioritizeTextures", _wrap_glPrioritizeTextures, 1 }, + { "glPopName", _wrap_glPopName, 1 }, + { "glPopMatrix", _wrap_glPopMatrix, 1 }, + { "glPopClientAttrib", _wrap_glPopClientAttrib, 1 }, + { "glPopAttrib", _wrap_glPopAttrib, 1 }, + { "glPolygonStipple", _wrap_glPolygonStipple, 1 }, + { "glPolygonOffset", _wrap_glPolygonOffset, 1 }, + { "glPolygonMode", _wrap_glPolygonMode, 1 }, + { "glPointSize", _wrap_glPointSize, 1 }, + { "glPixelZoom", _wrap_glPixelZoom, 1 }, + { "glPixelTransferi", _wrap_glPixelTransferi, 1 }, + { "glPixelTransferf", _wrap_glPixelTransferf, 1 }, + { "glPixelStorei", _wrap_glPixelStorei, 1 }, + { "glPixelStoref", _wrap_glPixelStoref, 1 }, + { "glPixelMapusv", _wrap_glPixelMapusv, 1 }, + { "glPixelMapuiv", _wrap_glPixelMapuiv, 1 }, + { "glPixelMapfv", _wrap_glPixelMapfv, 1 }, + { "glPassThrough", _wrap_glPassThrough, 1 }, + { "glOrtho", _wrap_glOrtho, 1 }, + { "glNormalPointer", _wrap_glNormalPointer, 1 }, + { "glNormal3sv", _wrap_glNormal3sv, 1 }, + { "glNormal3s", _wrap_glNormal3s, 1 }, + { "glNormal3iv", _wrap_glNormal3iv, 1 }, + { "glNormal3i", _wrap_glNormal3i, 1 }, + { "glNormal3fv", _wrap_glNormal3fv, 1 }, + { "glNormal3f", _wrap_glNormal3f, 1 }, + { "glNormal3dv", _wrap_glNormal3dv, 1 }, + { "glNormal3d", _wrap_glNormal3d, 1 }, + { "glNormal3bv", _wrap_glNormal3bv, 1 }, + { "glNormal3b", _wrap_glNormal3b, 1 }, + { "glNewList", _wrap_glNewList, 1 }, + { "glMultMatrixf", _wrap_glMultMatrixf, 1 }, + { "glMultMatrixd", _wrap_glMultMatrixd, 1 }, + { "glMatrixMode", _wrap_glMatrixMode, 1 }, + { "glMaterialiv", _wrap_glMaterialiv, 1 }, + { "glMateriali", _wrap_glMateriali, 1 }, + { "glMaterialfv", _wrap_glMaterialfv, 1 }, + { "glMaterialf", _wrap_glMaterialf, 1 }, + { "glMapGrid2f", _wrap_glMapGrid2f, 1 }, + { "glMapGrid2d", _wrap_glMapGrid2d, 1 }, + { "glMapGrid1f", _wrap_glMapGrid1f, 1 }, + { "glMapGrid1d", _wrap_glMapGrid1d, 1 }, + { "glMap2f", _wrap_glMap2f, 1 }, + { "glMap2d", _wrap_glMap2d, 1 }, + { "glMap1f", _wrap_glMap1f, 1 }, + { "glMap1d", _wrap_glMap1d, 1 }, + { "glLogicOp", _wrap_glLogicOp, 1 }, + { "glLoadName", _wrap_glLoadName, 1 }, + { "glLoadMatrixf", _wrap_glLoadMatrixf, 1 }, + { "glLoadMatrixd", _wrap_glLoadMatrixd, 1 }, + { "glLoadIdentity", _wrap_glLoadIdentity, 1 }, + { "glListBase", _wrap_glListBase, 1 }, + { "glLineWidth", _wrap_glLineWidth, 1 }, + { "glLineStipple", _wrap_glLineStipple, 1 }, + { "glLightiv", _wrap_glLightiv, 1 }, + { "glLighti", _wrap_glLighti, 1 }, + { "glLightfv", _wrap_glLightfv, 1 }, + { "glLightf", _wrap_glLightf, 1 }, + { "glLightModeliv", _wrap_glLightModeliv, 1 }, + { "glLightModeli", _wrap_glLightModeli, 1 }, + { "glLightModelfv", _wrap_glLightModelfv, 1 }, + { "glLightModelf", _wrap_glLightModelf, 1 }, + { "glIsTexture", _wrap_glIsTexture, 1 }, + { "glIsList", _wrap_glIsList, 1 }, + { "glIsEnabled", _wrap_glIsEnabled, 1 }, + { "glInterleavedArrays", _wrap_glInterleavedArrays, 1 }, + { "glInitNames", _wrap_glInitNames, 1 }, + { "glIndexubv", _wrap_glIndexubv, 1 }, + { "glIndexub", _wrap_glIndexub, 1 }, + { "glIndexsv", _wrap_glIndexsv, 1 }, + { "glIndexs", _wrap_glIndexs, 1 }, + { "glIndexiv", _wrap_glIndexiv, 1 }, + { "glIndexi", _wrap_glIndexi, 1 }, + { "glIndexfv", _wrap_glIndexfv, 1 }, + { "glIndexf", _wrap_glIndexf, 1 }, + { "glIndexdv", _wrap_glIndexdv, 1 }, + { "glIndexd", _wrap_glIndexd, 1 }, + { "glIndexPointer", _wrap_glIndexPointer, 1 }, + { "glIndexMask", _wrap_glIndexMask, 1 }, + { "glHint", _wrap_glHint, 1 }, + { "glGetTexParameteriv", _wrap_glGetTexParameteriv, 1 }, + { "glGetTexParameterfv", _wrap_glGetTexParameterfv, 1 }, + { "glGetTexLevelParameteriv", _wrap_glGetTexLevelParameteriv, 1 }, + { "glGetTexLevelParameterfv", _wrap_glGetTexLevelParameterfv, 1 }, + { "glGetTexImage", _wrap_glGetTexImage, 1 }, + { "glGetTexGeniv", _wrap_glGetTexGeniv, 1 }, + { "glGetTexGenfv", _wrap_glGetTexGenfv, 1 }, + { "glGetTexGendv", _wrap_glGetTexGendv, 1 }, + { "glGetTexEnviv", _wrap_glGetTexEnviv, 1 }, + { "glGetTexEnvfv", _wrap_glGetTexEnvfv, 1 }, + { "glGetString", _wrap_glGetString, 1 }, + { "glGetPolygonStipple", _wrap_glGetPolygonStipple, 1 }, + { "glGetPointerv", _wrap_glGetPointerv, 1 }, + { "glGetPixelMapusv", _wrap_glGetPixelMapusv, 1 }, + { "glGetPixelMapuiv", _wrap_glGetPixelMapuiv, 1 }, + { "glGetPixelMapfv", _wrap_glGetPixelMapfv, 1 }, + { "glGetMaterialiv", _wrap_glGetMaterialiv, 1 }, + { "glGetMaterialfv", _wrap_glGetMaterialfv, 1 }, + { "glGetMapiv", _wrap_glGetMapiv, 1 }, + { "glGetMapfv", _wrap_glGetMapfv, 1 }, + { "glGetMapdv", _wrap_glGetMapdv, 1 }, + { "glGetLightiv", _wrap_glGetLightiv, 1 }, + { "glGetLightfv", _wrap_glGetLightfv, 1 }, + { "glGetIntegerv", _wrap_glGetIntegerv, 1 }, + { "glGetFloatv", _wrap_glGetFloatv, 1 }, + { "glGetError", _wrap_glGetError, 1 }, + { "glGetDoublev", _wrap_glGetDoublev, 1 }, + { "glGetClipPlane", _wrap_glGetClipPlane, 1 }, + { "glGetBooleanv", _wrap_glGetBooleanv, 1 }, + { "glGenTextures", _wrap_glGenTextures, 1 }, + { "glGenLists", _wrap_glGenLists, 1 }, + { "glFrustum", _wrap_glFrustum, 1 }, + { "glFrontFace", _wrap_glFrontFace, 1 }, + { "glFogiv", _wrap_glFogiv, 1 }, + { "glFogi", _wrap_glFogi, 1 }, + { "glFogfv", _wrap_glFogfv, 1 }, + { "glFogf", _wrap_glFogf, 1 }, + { "glFlush", _wrap_glFlush, 1 }, + { "glFinish", _wrap_glFinish, 1 }, + { "glFeedbackBuffer", _wrap_glFeedbackBuffer, 1 }, + { "glEvalPoint2", _wrap_glEvalPoint2, 1 }, + { "glEvalPoint1", _wrap_glEvalPoint1, 1 }, + { "glEvalMesh2", _wrap_glEvalMesh2, 1 }, + { "glEvalMesh1", _wrap_glEvalMesh1, 1 }, + { "glEvalCoord2fv", _wrap_glEvalCoord2fv, 1 }, + { "glEvalCoord2f", _wrap_glEvalCoord2f, 1 }, + { "glEvalCoord2dv", _wrap_glEvalCoord2dv, 1 }, + { "glEvalCoord2d", _wrap_glEvalCoord2d, 1 }, + { "glEvalCoord1fv", _wrap_glEvalCoord1fv, 1 }, + { "glEvalCoord1f", _wrap_glEvalCoord1f, 1 }, + { "glEvalCoord1dv", _wrap_glEvalCoord1dv, 1 }, + { "glEvalCoord1d", _wrap_glEvalCoord1d, 1 }, + { "glEndList", _wrap_glEndList, 1 }, + { "glEnd", _wrap_glEnd, 1 }, + { "glEnableClientState", _wrap_glEnableClientState, 1 }, + { "glEnable", _wrap_glEnable, 1 }, + { "glEdgeFlagv", _wrap_glEdgeFlagv, 1 }, + { "glEdgeFlagPointer", _wrap_glEdgeFlagPointer, 1 }, + { "glEdgeFlag", _wrap_glEdgeFlag, 1 }, + { "glDrawPixels", _wrap_glDrawPixels, 1 }, + { "glDrawElements", _wrap_glDrawElements, 1 }, + { "glDrawBuffer", _wrap_glDrawBuffer, 1 }, + { "glDrawArrays", _wrap_glDrawArrays, 1 }, + { "glDisableClientState", _wrap_glDisableClientState, 1 }, + { "glDisable", _wrap_glDisable, 1 }, + { "glDepthRange", _wrap_glDepthRange, 1 }, + { "glDepthMask", _wrap_glDepthMask, 1 }, + { "glDepthFunc", _wrap_glDepthFunc, 1 }, + { "glDeleteTextures", _wrap_glDeleteTextures, 1 }, + { "glDeleteLists", _wrap_glDeleteLists, 1 }, + { "glCullFace", _wrap_glCullFace, 1 }, + { "glCopyTexSubImage2D", _wrap_glCopyTexSubImage2D, 1 }, + { "glCopyTexSubImage1D", _wrap_glCopyTexSubImage1D, 1 }, + { "glCopyTexImage2D", _wrap_glCopyTexImage2D, 1 }, + { "glCopyTexImage1D", _wrap_glCopyTexImage1D, 1 }, + { "glCopyPixels", _wrap_glCopyPixels, 1 }, + { "glColorPointer", _wrap_glColorPointer, 1 }, + { "glColorMaterial", _wrap_glColorMaterial, 1 }, + { "glColorMask", _wrap_glColorMask, 1 }, + { "glColor4usv", _wrap_glColor4usv, 1 }, + { "glColor4us", _wrap_glColor4us, 1 }, + { "glColor4uiv", _wrap_glColor4uiv, 1 }, + { "glColor4ui", _wrap_glColor4ui, 1 }, + { "glColor4ubv", _wrap_glColor4ubv, 1 }, + { "glColor4ub", _wrap_glColor4ub, 1 }, + { "glColor4sv", _wrap_glColor4sv, 1 }, + { "glColor4s", _wrap_glColor4s, 1 }, + { "glColor4iv", _wrap_glColor4iv, 1 }, + { "glColor4i", _wrap_glColor4i, 1 }, + { "glColor4fv", _wrap_glColor4fv, 1 }, + { "glColor4f", _wrap_glColor4f, 1 }, + { "glColor4dv", _wrap_glColor4dv, 1 }, + { "glColor4d", _wrap_glColor4d, 1 }, + { "glColor4bv", _wrap_glColor4bv, 1 }, + { "glColor4b", _wrap_glColor4b, 1 }, + { "glColor3usv", _wrap_glColor3usv, 1 }, + { "glColor3us", _wrap_glColor3us, 1 }, + { "glColor3uiv", _wrap_glColor3uiv, 1 }, + { "glColor3ui", _wrap_glColor3ui, 1 }, + { "glColor3ubv", _wrap_glColor3ubv, 1 }, + { "glColor3ub", _wrap_glColor3ub, 1 }, + { "glColor3sv", _wrap_glColor3sv, 1 }, + { "glColor3s", _wrap_glColor3s, 1 }, + { "glColor3iv", _wrap_glColor3iv, 1 }, + { "glColor3i", _wrap_glColor3i, 1 }, + { "glColor3fv", _wrap_glColor3fv, 1 }, + { "glColor3f", _wrap_glColor3f, 1 }, + { "glColor3dv", _wrap_glColor3dv, 1 }, + { "glColor3d", _wrap_glColor3d, 1 }, + { "glColor3bv", _wrap_glColor3bv, 1 }, + { "glColor3b", _wrap_glColor3b, 1 }, + { "glClipPlane", _wrap_glClipPlane, 1 }, + { "glClearStencil", _wrap_glClearStencil, 1 }, + { "glClearIndex", _wrap_glClearIndex, 1 }, + { "glClearDepth", _wrap_glClearDepth, 1 }, + { "glClearColor", _wrap_glClearColor, 1 }, + { "glClearAccum", _wrap_glClearAccum, 1 }, + { "glClear", _wrap_glClear, 1 }, + { "glCallLists", _wrap_glCallLists, 1 }, + { "glCallList", _wrap_glCallList, 1 }, + { "glBlendFunc", _wrap_glBlendFunc, 1 }, + { "glBitmap", _wrap_glBitmap, 1 }, + { "glBindTexture", _wrap_glBindTexture, 1 }, + { "glBegin", _wrap_glBegin, 1 }, + { "glArrayElement", _wrap_glArrayElement, 1 }, + { "glAreTexturesResident", _wrap_glAreTexturesResident, 1 }, + { "glAlphaFunc", _wrap_glAlphaFunc, 1 }, + { "glAccum", _wrap_glAccum, 1 }, + { "glAddSwapHintRectWin", _wrap_glAddSwapHintRectWin, 1 }, + { "glIndexMaterialSGI", _wrap_glIndexMaterialSGI, 1 }, + { "glIndexFuncSGI", _wrap_glIndexFuncSGI, 1 }, + { "glCullParameterfvSGI", _wrap_glCullParameterfvSGI, 1 }, + { "glCullParameterdvSGI", _wrap_glCullParameterdvSGI, 1 }, + { "glUnlockArraysSGI", _wrap_glUnlockArraysSGI, 1 }, + { "glLockArraysSGI", _wrap_glLockArraysSGI, 1 }, + { "glGetColorTavleParameterivEXT", _wrap_glGetColorTavleParameterivEXT, 1 }, + { "glGetColorTableParamaterfvEXT", _wrap_glGetColorTableParamaterfvEXT, 1 }, + { "glGetColorTableEXT", _wrap_glGetColorTableEXT, 1 }, + { "glCopyColorTableEXT", _wrap_glCopyColorTableEXT, 1 }, + { "glColorTableEXT", _wrap_glColorTableEXT, 1 }, + { "glColorSubtableEXT", _wrap_glColorSubtableEXT, 1 }, + { "glVertexPointerEXT", _wrap_glVertexPointerEXT, 1 }, + { "glTexCoordPointerEXT", _wrap_glTexCoordPointerEXT, 1 }, + { "glNormalPointerEXT", _wrap_glNormalPointerEXT, 1 }, + { "glIndexPointerEXT", _wrap_glIndexPointerEXT, 1 }, + { "glGetPointervEXT", _wrap_glGetPointervEXT, 1 }, + { "glEdgeFlagPointerEXT", _wrap_glEdgeFlagPointerEXT, 1 }, + { "glDrawArraysEXT", _wrap_glDrawArraysEXT, 1 }, + { "glColorPointerEXT", _wrap_glColorPointerEXT, 1 }, + { "glArrayElementEXT", _wrap_glArrayElementEXT, 1 }, + { NULL, NULL } +}; +static PyObject *SWIG_globals; +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT(void,initglcanvasc)() { + PyObject *m, *d; + SWIG_globals = SWIG_newvarlink(); + m = Py_InitModule("glcanvasc", glcanvascMethods); + d = PyModule_GetDict(m); + PyDict_SetItemString(d,"GL_2D", PyInt_FromLong((long) GL_2D)); + PyDict_SetItemString(d,"GL_2_BYTES", PyInt_FromLong((long) GL_2_BYTES)); + PyDict_SetItemString(d,"GL_3D", PyInt_FromLong((long) GL_3D)); + PyDict_SetItemString(d,"GL_3D_COLOR", PyInt_FromLong((long) GL_3D_COLOR)); + PyDict_SetItemString(d,"GL_3D_COLOR_TEXTURE", PyInt_FromLong((long) GL_3D_COLOR_TEXTURE)); + PyDict_SetItemString(d,"GL_3_BYTES", PyInt_FromLong((long) GL_3_BYTES)); + PyDict_SetItemString(d,"GL_4D_COLOR_TEXTURE", PyInt_FromLong((long) GL_4D_COLOR_TEXTURE)); + PyDict_SetItemString(d,"GL_4_BYTES", PyInt_FromLong((long) GL_4_BYTES)); + PyDict_SetItemString(d,"GL_ACCUM", PyInt_FromLong((long) GL_ACCUM)); + PyDict_SetItemString(d,"GL_ACCUM_ALPHA_BITS", PyInt_FromLong((long) GL_ACCUM_ALPHA_BITS)); + PyDict_SetItemString(d,"GL_ACCUM_BLUE_BITS", PyInt_FromLong((long) GL_ACCUM_BLUE_BITS)); + PyDict_SetItemString(d,"GL_ACCUM_BUFFER_BIT", PyInt_FromLong((long) GL_ACCUM_BUFFER_BIT)); + PyDict_SetItemString(d,"GL_ACCUM_CLEAR_VALUE", PyInt_FromLong((long) GL_ACCUM_CLEAR_VALUE)); + PyDict_SetItemString(d,"GL_ACCUM_GREEN_BITS", PyInt_FromLong((long) GL_ACCUM_GREEN_BITS)); + PyDict_SetItemString(d,"GL_ACCUM_RED_BITS", PyInt_FromLong((long) GL_ACCUM_RED_BITS)); + PyDict_SetItemString(d,"GL_ADD", PyInt_FromLong((long) GL_ADD)); + PyDict_SetItemString(d,"GL_ALL_ATTRIB_BITS", PyInt_FromLong((long) GL_ALL_ATTRIB_BITS)); + PyDict_SetItemString(d,"GL_ALPHA", PyInt_FromLong((long) GL_ALPHA)); + PyDict_SetItemString(d,"GL_ALPHA12", PyInt_FromLong((long) GL_ALPHA12)); + PyDict_SetItemString(d,"GL_ALPHA16", PyInt_FromLong((long) GL_ALPHA16)); + PyDict_SetItemString(d,"GL_ALPHA4", PyInt_FromLong((long) GL_ALPHA4)); + PyDict_SetItemString(d,"GL_ALPHA8", PyInt_FromLong((long) GL_ALPHA8)); + PyDict_SetItemString(d,"GL_ALPHA_BIAS", PyInt_FromLong((long) GL_ALPHA_BIAS)); + PyDict_SetItemString(d,"GL_ALPHA_BITS", PyInt_FromLong((long) GL_ALPHA_BITS)); + PyDict_SetItemString(d,"GL_ALPHA_SCALE", PyInt_FromLong((long) GL_ALPHA_SCALE)); + PyDict_SetItemString(d,"GL_ALPHA_TEST", PyInt_FromLong((long) GL_ALPHA_TEST)); + PyDict_SetItemString(d,"GL_ALPHA_TEST_FUNC", PyInt_FromLong((long) GL_ALPHA_TEST_FUNC)); + PyDict_SetItemString(d,"GL_ALPHA_TEST_REF", PyInt_FromLong((long) GL_ALPHA_TEST_REF)); + PyDict_SetItemString(d,"GL_ALWAYS", PyInt_FromLong((long) GL_ALWAYS)); + PyDict_SetItemString(d,"GL_AMBIENT", PyInt_FromLong((long) GL_AMBIENT)); + PyDict_SetItemString(d,"GL_AMBIENT_AND_DIFFUSE", PyInt_FromLong((long) GL_AMBIENT_AND_DIFFUSE)); + PyDict_SetItemString(d,"GL_AND", PyInt_FromLong((long) GL_AND)); + PyDict_SetItemString(d,"GL_AND_INVERTED", PyInt_FromLong((long) GL_AND_INVERTED)); + PyDict_SetItemString(d,"GL_AND_REVERSE", PyInt_FromLong((long) GL_AND_REVERSE)); + PyDict_SetItemString(d,"GL_ATTRIB_STACK_DEPTH", PyInt_FromLong((long) GL_ATTRIB_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_AUTO_NORMAL", PyInt_FromLong((long) GL_AUTO_NORMAL)); + PyDict_SetItemString(d,"GL_AUX0", PyInt_FromLong((long) GL_AUX0)); + PyDict_SetItemString(d,"GL_AUX1", PyInt_FromLong((long) GL_AUX1)); + PyDict_SetItemString(d,"GL_AUX2", PyInt_FromLong((long) GL_AUX2)); + PyDict_SetItemString(d,"GL_AUX3", PyInt_FromLong((long) GL_AUX3)); + PyDict_SetItemString(d,"GL_AUX_BUFFERS", PyInt_FromLong((long) GL_AUX_BUFFERS)); + PyDict_SetItemString(d,"GL_BACK", PyInt_FromLong((long) GL_BACK)); + PyDict_SetItemString(d,"GL_BACK_LEFT", PyInt_FromLong((long) GL_BACK_LEFT)); + PyDict_SetItemString(d,"GL_BACK_RIGHT", PyInt_FromLong((long) GL_BACK_RIGHT)); + PyDict_SetItemString(d,"GL_BGRA_EXT", PyInt_FromLong((long) GL_BGRA_EXT)); + PyDict_SetItemString(d,"GL_BGR_EXT", PyInt_FromLong((long) GL_BGR_EXT)); + PyDict_SetItemString(d,"GL_BITMAP", PyInt_FromLong((long) GL_BITMAP)); + PyDict_SetItemString(d,"GL_BITMAP_TOKEN", PyInt_FromLong((long) GL_BITMAP_TOKEN)); + PyDict_SetItemString(d,"GL_BLEND", PyInt_FromLong((long) GL_BLEND)); + PyDict_SetItemString(d,"GL_BLEND_DST", PyInt_FromLong((long) GL_BLEND_DST)); + PyDict_SetItemString(d,"GL_BLEND_SRC", PyInt_FromLong((long) GL_BLEND_SRC)); + PyDict_SetItemString(d,"GL_BLUE", PyInt_FromLong((long) GL_BLUE)); + PyDict_SetItemString(d,"GL_BLUE_BIAS", PyInt_FromLong((long) GL_BLUE_BIAS)); + PyDict_SetItemString(d,"GL_BLUE_BITS", PyInt_FromLong((long) GL_BLUE_BITS)); + PyDict_SetItemString(d,"GL_BLUE_SCALE", PyInt_FromLong((long) GL_BLUE_SCALE)); + PyDict_SetItemString(d,"GL_BYTE", PyInt_FromLong((long) GL_BYTE)); + PyDict_SetItemString(d,"GL_C3F_V3F", PyInt_FromLong((long) GL_C3F_V3F)); + PyDict_SetItemString(d,"GL_C4F_N3F_V3F", PyInt_FromLong((long) GL_C4F_N3F_V3F)); + PyDict_SetItemString(d,"GL_C4UB_V2F", PyInt_FromLong((long) GL_C4UB_V2F)); + PyDict_SetItemString(d,"GL_C4UB_V3F", PyInt_FromLong((long) GL_C4UB_V3F)); + PyDict_SetItemString(d,"GL_CCW", PyInt_FromLong((long) GL_CCW)); + PyDict_SetItemString(d,"GL_CLAMP", PyInt_FromLong((long) GL_CLAMP)); + PyDict_SetItemString(d,"GL_CLEAR", PyInt_FromLong((long) GL_CLEAR)); + PyDict_SetItemString(d,"GL_CLIENT_ALL_ATTRIB_BITS", PyInt_FromLong((long) GL_CLIENT_ALL_ATTRIB_BITS)); + PyDict_SetItemString(d,"GL_CLIENT_ATTRIB_STACK_DEPTH", PyInt_FromLong((long) GL_CLIENT_ATTRIB_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_CLIENT_PIXEL_STORE_BIT", PyInt_FromLong((long) GL_CLIENT_PIXEL_STORE_BIT)); + PyDict_SetItemString(d,"GL_CLIENT_VERTEX_ARRAY_BIT", PyInt_FromLong((long) GL_CLIENT_VERTEX_ARRAY_BIT)); + PyDict_SetItemString(d,"GL_CLIP_PLANE0", PyInt_FromLong((long) GL_CLIP_PLANE0)); + PyDict_SetItemString(d,"GL_CLIP_PLANE1", PyInt_FromLong((long) GL_CLIP_PLANE1)); + PyDict_SetItemString(d,"GL_CLIP_PLANE2", PyInt_FromLong((long) GL_CLIP_PLANE2)); + PyDict_SetItemString(d,"GL_CLIP_PLANE3", PyInt_FromLong((long) GL_CLIP_PLANE3)); + PyDict_SetItemString(d,"GL_CLIP_PLANE4", PyInt_FromLong((long) GL_CLIP_PLANE4)); + PyDict_SetItemString(d,"GL_CLIP_PLANE5", PyInt_FromLong((long) GL_CLIP_PLANE5)); + PyDict_SetItemString(d,"GL_COEFF", PyInt_FromLong((long) GL_COEFF)); + PyDict_SetItemString(d,"GL_COLOR", PyInt_FromLong((long) GL_COLOR)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY", PyInt_FromLong((long) GL_COLOR_ARRAY)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_COUNT_EXT", PyInt_FromLong((long) GL_COLOR_ARRAY_COUNT_EXT)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_EXT", PyInt_FromLong((long) GL_COLOR_ARRAY_EXT)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_POINTER", PyInt_FromLong((long) GL_COLOR_ARRAY_POINTER)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_POINTER_EXT", PyInt_FromLong((long) GL_COLOR_ARRAY_POINTER_EXT)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_SIZE", PyInt_FromLong((long) GL_COLOR_ARRAY_SIZE)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_SIZE_EXT", PyInt_FromLong((long) GL_COLOR_ARRAY_SIZE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_STRIDE", PyInt_FromLong((long) GL_COLOR_ARRAY_STRIDE)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_STRIDE_EXT", PyInt_FromLong((long) GL_COLOR_ARRAY_STRIDE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_TYPE", PyInt_FromLong((long) GL_COLOR_ARRAY_TYPE)); + PyDict_SetItemString(d,"GL_COLOR_ARRAY_TYPE_EXT", PyInt_FromLong((long) GL_COLOR_ARRAY_TYPE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_BUFFER_BIT", PyInt_FromLong((long) GL_COLOR_BUFFER_BIT)); + PyDict_SetItemString(d,"GL_COLOR_CLEAR_VALUE", PyInt_FromLong((long) GL_COLOR_CLEAR_VALUE)); + PyDict_SetItemString(d,"GL_COLOR_INDEX", PyInt_FromLong((long) GL_COLOR_INDEX)); + PyDict_SetItemString(d,"GL_COLOR_INDEX12_EXT", PyInt_FromLong((long) GL_COLOR_INDEX12_EXT)); + PyDict_SetItemString(d,"GL_COLOR_INDEX16_EXT", PyInt_FromLong((long) GL_COLOR_INDEX16_EXT)); + PyDict_SetItemString(d,"GL_COLOR_INDEX1_EXT", PyInt_FromLong((long) GL_COLOR_INDEX1_EXT)); + PyDict_SetItemString(d,"GL_COLOR_INDEX2_EXT", PyInt_FromLong((long) GL_COLOR_INDEX2_EXT)); + PyDict_SetItemString(d,"GL_COLOR_INDEX4_EXT", PyInt_FromLong((long) GL_COLOR_INDEX4_EXT)); + PyDict_SetItemString(d,"GL_COLOR_INDEX8_EXT", PyInt_FromLong((long) GL_COLOR_INDEX8_EXT)); + PyDict_SetItemString(d,"GL_COLOR_INDEXES", PyInt_FromLong((long) GL_COLOR_INDEXES)); + PyDict_SetItemString(d,"GL_COLOR_LOGIC_OP", PyInt_FromLong((long) GL_COLOR_LOGIC_OP)); + PyDict_SetItemString(d,"GL_COLOR_MATERIAL", PyInt_FromLong((long) GL_COLOR_MATERIAL)); + PyDict_SetItemString(d,"GL_COLOR_MATERIAL_FACE", PyInt_FromLong((long) GL_COLOR_MATERIAL_FACE)); + PyDict_SetItemString(d,"GL_COLOR_MATERIAL_PARAMETER", PyInt_FromLong((long) GL_COLOR_MATERIAL_PARAMETER)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_ALPHA_SIZE_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_ALPHA_SIZE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_BLUE_SIZE_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_BLUE_SIZE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_FORMAT_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_FORMAT_EXT)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_GREEN_SIZE_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_GREEN_SIZE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_INTENSITY_SIZE_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_INTENSITY_SIZE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_LUMINANCE_SIZE_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_LUMINANCE_SIZE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_RED_SIZE_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_RED_SIZE_EXT)); + PyDict_SetItemString(d,"GL_COLOR_TABLE_WIDTH_EXT", PyInt_FromLong((long) GL_COLOR_TABLE_WIDTH_EXT)); + PyDict_SetItemString(d,"GL_COLOR_WRITEMASK", PyInt_FromLong((long) GL_COLOR_WRITEMASK)); + PyDict_SetItemString(d,"GL_COMPILE", PyInt_FromLong((long) GL_COMPILE)); + PyDict_SetItemString(d,"GL_COMPILE_AND_EXECUTE", PyInt_FromLong((long) GL_COMPILE_AND_EXECUTE)); + PyDict_SetItemString(d,"GL_CONSTANT_ATTENUATION", PyInt_FromLong((long) GL_CONSTANT_ATTENUATION)); + PyDict_SetItemString(d,"GL_COPY", PyInt_FromLong((long) GL_COPY)); + PyDict_SetItemString(d,"GL_COPY_INVERTED", PyInt_FromLong((long) GL_COPY_INVERTED)); + PyDict_SetItemString(d,"GL_COPY_PIXEL_TOKEN", PyInt_FromLong((long) GL_COPY_PIXEL_TOKEN)); + PyDict_SetItemString(d,"GL_CULL_FACE", PyInt_FromLong((long) GL_CULL_FACE)); + PyDict_SetItemString(d,"GL_CULL_FACE_MODE", PyInt_FromLong((long) GL_CULL_FACE_MODE)); + PyDict_SetItemString(d,"GL_CURRENT_BIT", PyInt_FromLong((long) GL_CURRENT_BIT)); + PyDict_SetItemString(d,"GL_CURRENT_COLOR", PyInt_FromLong((long) GL_CURRENT_COLOR)); + PyDict_SetItemString(d,"GL_CURRENT_INDEX", PyInt_FromLong((long) GL_CURRENT_INDEX)); + PyDict_SetItemString(d,"GL_CURRENT_NORMAL", PyInt_FromLong((long) GL_CURRENT_NORMAL)); + PyDict_SetItemString(d,"GL_CURRENT_RASTER_COLOR", PyInt_FromLong((long) GL_CURRENT_RASTER_COLOR)); + PyDict_SetItemString(d,"GL_CURRENT_RASTER_DISTANCE", PyInt_FromLong((long) GL_CURRENT_RASTER_DISTANCE)); + PyDict_SetItemString(d,"GL_CURRENT_RASTER_INDEX", PyInt_FromLong((long) GL_CURRENT_RASTER_INDEX)); + PyDict_SetItemString(d,"GL_CURRENT_RASTER_POSITION", PyInt_FromLong((long) GL_CURRENT_RASTER_POSITION)); + PyDict_SetItemString(d,"GL_CURRENT_RASTER_POSITION_VALID", PyInt_FromLong((long) GL_CURRENT_RASTER_POSITION_VALID)); + PyDict_SetItemString(d,"GL_CURRENT_RASTER_TEXTURE_COORDS", PyInt_FromLong((long) GL_CURRENT_RASTER_TEXTURE_COORDS)); + PyDict_SetItemString(d,"GL_CURRENT_TEXTURE_COORDS", PyInt_FromLong((long) GL_CURRENT_TEXTURE_COORDS)); + PyDict_SetItemString(d,"GL_CW", PyInt_FromLong((long) GL_CW)); + PyDict_SetItemString(d,"GL_DECAL", PyInt_FromLong((long) GL_DECAL)); + PyDict_SetItemString(d,"GL_DECR", PyInt_FromLong((long) GL_DECR)); + PyDict_SetItemString(d,"GL_DEPTH", PyInt_FromLong((long) GL_DEPTH)); + PyDict_SetItemString(d,"GL_DEPTH_BIAS", PyInt_FromLong((long) GL_DEPTH_BIAS)); + PyDict_SetItemString(d,"GL_DEPTH_BITS", PyInt_FromLong((long) GL_DEPTH_BITS)); + PyDict_SetItemString(d,"GL_DEPTH_BUFFER_BIT", PyInt_FromLong((long) GL_DEPTH_BUFFER_BIT)); + PyDict_SetItemString(d,"GL_DEPTH_CLEAR_VALUE", PyInt_FromLong((long) GL_DEPTH_CLEAR_VALUE)); + PyDict_SetItemString(d,"GL_DEPTH_COMPONENT", PyInt_FromLong((long) GL_DEPTH_COMPONENT)); + PyDict_SetItemString(d,"GL_DEPTH_FUNC", PyInt_FromLong((long) GL_DEPTH_FUNC)); + PyDict_SetItemString(d,"GL_DEPTH_RANGE", PyInt_FromLong((long) GL_DEPTH_RANGE)); + PyDict_SetItemString(d,"GL_DEPTH_SCALE", PyInt_FromLong((long) GL_DEPTH_SCALE)); + PyDict_SetItemString(d,"GL_DEPTH_TEST", PyInt_FromLong((long) GL_DEPTH_TEST)); + PyDict_SetItemString(d,"GL_DEPTH_WRITEMASK", PyInt_FromLong((long) GL_DEPTH_WRITEMASK)); + PyDict_SetItemString(d,"GL_DIFFUSE", PyInt_FromLong((long) GL_DIFFUSE)); + PyDict_SetItemString(d,"GL_DITHER", PyInt_FromLong((long) GL_DITHER)); + PyDict_SetItemString(d,"GL_DOMAIN", PyInt_FromLong((long) GL_DOMAIN)); + PyDict_SetItemString(d,"GL_DONT_CARE", PyInt_FromLong((long) GL_DONT_CARE)); + PyDict_SetItemString(d,"GL_DOUBLE", PyInt_FromLong((long) GL_DOUBLE)); + PyDict_SetItemString(d,"GL_DOUBLEBUFFER", PyInt_FromLong((long) GL_DOUBLEBUFFER)); + PyDict_SetItemString(d,"GL_DOUBLE_EXT", PyInt_FromLong((long) GL_DOUBLE_EXT)); + PyDict_SetItemString(d,"GL_DRAW_BUFFER", PyInt_FromLong((long) GL_DRAW_BUFFER)); + PyDict_SetItemString(d,"GL_DRAW_PIXEL_TOKEN", PyInt_FromLong((long) GL_DRAW_PIXEL_TOKEN)); + PyDict_SetItemString(d,"GL_DST_ALPHA", PyInt_FromLong((long) GL_DST_ALPHA)); + PyDict_SetItemString(d,"GL_DST_COLOR", PyInt_FromLong((long) GL_DST_COLOR)); + PyDict_SetItemString(d,"GL_EDGE_FLAG", PyInt_FromLong((long) GL_EDGE_FLAG)); + PyDict_SetItemString(d,"GL_EDGE_FLAG_ARRAY", PyInt_FromLong((long) GL_EDGE_FLAG_ARRAY)); + PyDict_SetItemString(d,"GL_EDGE_FLAG_ARRAY_COUNT_EXT", PyInt_FromLong((long) GL_EDGE_FLAG_ARRAY_COUNT_EXT)); + PyDict_SetItemString(d,"GL_EDGE_FLAG_ARRAY_EXT", PyInt_FromLong((long) GL_EDGE_FLAG_ARRAY_EXT)); + PyDict_SetItemString(d,"GL_EDGE_FLAG_ARRAY_POINTER", PyInt_FromLong((long) GL_EDGE_FLAG_ARRAY_POINTER)); + PyDict_SetItemString(d,"GL_EDGE_FLAG_ARRAY_POINTER_EXT", PyInt_FromLong((long) GL_EDGE_FLAG_ARRAY_POINTER_EXT)); + PyDict_SetItemString(d,"GL_EDGE_FLAG_ARRAY_STRIDE", PyInt_FromLong((long) GL_EDGE_FLAG_ARRAY_STRIDE)); + PyDict_SetItemString(d,"GL_EDGE_FLAG_ARRAY_STRIDE_EXT", PyInt_FromLong((long) GL_EDGE_FLAG_ARRAY_STRIDE_EXT)); + PyDict_SetItemString(d,"GL_EMISSION", PyInt_FromLong((long) GL_EMISSION)); + PyDict_SetItemString(d,"GL_ENABLE_BIT", PyInt_FromLong((long) GL_ENABLE_BIT)); + PyDict_SetItemString(d,"GL_EQUAL", PyInt_FromLong((long) GL_EQUAL)); + PyDict_SetItemString(d,"GL_EQUIV", PyInt_FromLong((long) GL_EQUIV)); + PyDict_SetItemString(d,"GL_EVAL_BIT", PyInt_FromLong((long) GL_EVAL_BIT)); + PyDict_SetItemString(d,"GL_EXP", PyInt_FromLong((long) GL_EXP)); + PyDict_SetItemString(d,"GL_EXP2", PyInt_FromLong((long) GL_EXP2)); + PyDict_SetItemString(d,"GL_EXTENSIONS", PyInt_FromLong((long) GL_EXTENSIONS)); + PyDict_SetItemString(d,"GL_EXT_bgra", PyInt_FromLong((long) GL_EXT_bgra)); + PyDict_SetItemString(d,"GL_EXT_paletted_texture", PyInt_FromLong((long) GL_EXT_paletted_texture)); + PyDict_SetItemString(d,"GL_EXT_vertex_array", PyInt_FromLong((long) GL_EXT_vertex_array)); + PyDict_SetItemString(d,"GL_EYE_LINEAR", PyInt_FromLong((long) GL_EYE_LINEAR)); + PyDict_SetItemString(d,"GL_EYE_PLANE", PyInt_FromLong((long) GL_EYE_PLANE)); + PyDict_SetItemString(d,"GL_FALSE", PyInt_FromLong((long) GL_FALSE)); + PyDict_SetItemString(d,"GL_FASTEST", PyInt_FromLong((long) GL_FASTEST)); + PyDict_SetItemString(d,"GL_FEEDBACK", PyInt_FromLong((long) GL_FEEDBACK)); + PyDict_SetItemString(d,"GL_FEEDBACK_BUFFER_POINTER", PyInt_FromLong((long) GL_FEEDBACK_BUFFER_POINTER)); + PyDict_SetItemString(d,"GL_FEEDBACK_BUFFER_SIZE", PyInt_FromLong((long) GL_FEEDBACK_BUFFER_SIZE)); + PyDict_SetItemString(d,"GL_FEEDBACK_BUFFER_TYPE", PyInt_FromLong((long) GL_FEEDBACK_BUFFER_TYPE)); + PyDict_SetItemString(d,"GL_FILL", PyInt_FromLong((long) GL_FILL)); + PyDict_SetItemString(d,"GL_FLAT", PyInt_FromLong((long) GL_FLAT)); + PyDict_SetItemString(d,"GL_FLOAT", PyInt_FromLong((long) GL_FLOAT)); + PyDict_SetItemString(d,"GL_FOG", PyInt_FromLong((long) GL_FOG)); + PyDict_SetItemString(d,"GL_FOG_BIT", PyInt_FromLong((long) GL_FOG_BIT)); + PyDict_SetItemString(d,"GL_FOG_COLOR", PyInt_FromLong((long) GL_FOG_COLOR)); + PyDict_SetItemString(d,"GL_FOG_DENSITY", PyInt_FromLong((long) GL_FOG_DENSITY)); + PyDict_SetItemString(d,"GL_FOG_END", PyInt_FromLong((long) GL_FOG_END)); + PyDict_SetItemString(d,"GL_FOG_HINT", PyInt_FromLong((long) GL_FOG_HINT)); + PyDict_SetItemString(d,"GL_FOG_INDEX", PyInt_FromLong((long) GL_FOG_INDEX)); + PyDict_SetItemString(d,"GL_FOG_MODE", PyInt_FromLong((long) GL_FOG_MODE)); + PyDict_SetItemString(d,"GL_FOG_SPECULAR_TEXTURE_WIN", PyInt_FromLong((long) GL_FOG_SPECULAR_TEXTURE_WIN)); + PyDict_SetItemString(d,"GL_FOG_START", PyInt_FromLong((long) GL_FOG_START)); + PyDict_SetItemString(d,"GL_FRONT", PyInt_FromLong((long) GL_FRONT)); + PyDict_SetItemString(d,"GL_FRONT_AND_BACK", PyInt_FromLong((long) GL_FRONT_AND_BACK)); + PyDict_SetItemString(d,"GL_FRONT_FACE", PyInt_FromLong((long) GL_FRONT_FACE)); + PyDict_SetItemString(d,"GL_FRONT_LEFT", PyInt_FromLong((long) GL_FRONT_LEFT)); + PyDict_SetItemString(d,"GL_FRONT_RIGHT", PyInt_FromLong((long) GL_FRONT_RIGHT)); + PyDict_SetItemString(d,"GL_GEQUAL", PyInt_FromLong((long) GL_GEQUAL)); + PyDict_SetItemString(d,"GL_GREATER", PyInt_FromLong((long) GL_GREATER)); + PyDict_SetItemString(d,"GL_GREEN", PyInt_FromLong((long) GL_GREEN)); + PyDict_SetItemString(d,"GL_GREEN_BIAS", PyInt_FromLong((long) GL_GREEN_BIAS)); + PyDict_SetItemString(d,"GL_GREEN_BITS", PyInt_FromLong((long) GL_GREEN_BITS)); + PyDict_SetItemString(d,"GL_GREEN_SCALE", PyInt_FromLong((long) GL_GREEN_SCALE)); + PyDict_SetItemString(d,"GL_HINT_BIT", PyInt_FromLong((long) GL_HINT_BIT)); + PyDict_SetItemString(d,"GL_INCR", PyInt_FromLong((long) GL_INCR)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY", PyInt_FromLong((long) GL_INDEX_ARRAY)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_COUNT_EXT", PyInt_FromLong((long) GL_INDEX_ARRAY_COUNT_EXT)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_EXT", PyInt_FromLong((long) GL_INDEX_ARRAY_EXT)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_POINTER", PyInt_FromLong((long) GL_INDEX_ARRAY_POINTER)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_POINTER_EXT", PyInt_FromLong((long) GL_INDEX_ARRAY_POINTER_EXT)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_STRIDE", PyInt_FromLong((long) GL_INDEX_ARRAY_STRIDE)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_STRIDE_EXT", PyInt_FromLong((long) GL_INDEX_ARRAY_STRIDE_EXT)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_TYPE", PyInt_FromLong((long) GL_INDEX_ARRAY_TYPE)); + PyDict_SetItemString(d,"GL_INDEX_ARRAY_TYPE_EXT", PyInt_FromLong((long) GL_INDEX_ARRAY_TYPE_EXT)); + PyDict_SetItemString(d,"GL_INDEX_BITS", PyInt_FromLong((long) GL_INDEX_BITS)); + PyDict_SetItemString(d,"GL_INDEX_CLEAR_VALUE", PyInt_FromLong((long) GL_INDEX_CLEAR_VALUE)); + PyDict_SetItemString(d,"GL_INDEX_LOGIC_OP", PyInt_FromLong((long) GL_INDEX_LOGIC_OP)); + PyDict_SetItemString(d,"GL_INDEX_MODE", PyInt_FromLong((long) GL_INDEX_MODE)); + PyDict_SetItemString(d,"GL_INDEX_OFFSET", PyInt_FromLong((long) GL_INDEX_OFFSET)); + PyDict_SetItemString(d,"GL_INDEX_SHIFT", PyInt_FromLong((long) GL_INDEX_SHIFT)); + PyDict_SetItemString(d,"GL_INDEX_WRITEMASK", PyInt_FromLong((long) GL_INDEX_WRITEMASK)); + PyDict_SetItemString(d,"GL_INT", PyInt_FromLong((long) GL_INT)); + PyDict_SetItemString(d,"GL_INTENSITY", PyInt_FromLong((long) GL_INTENSITY)); + PyDict_SetItemString(d,"GL_INTENSITY12", PyInt_FromLong((long) GL_INTENSITY12)); + PyDict_SetItemString(d,"GL_INTENSITY16", PyInt_FromLong((long) GL_INTENSITY16)); + PyDict_SetItemString(d,"GL_INTENSITY4", PyInt_FromLong((long) GL_INTENSITY4)); + PyDict_SetItemString(d,"GL_INTENSITY8", PyInt_FromLong((long) GL_INTENSITY8)); + PyDict_SetItemString(d,"GL_INVALID_ENUM", PyInt_FromLong((long) GL_INVALID_ENUM)); + PyDict_SetItemString(d,"GL_INVALID_OPERATION", PyInt_FromLong((long) GL_INVALID_OPERATION)); + PyDict_SetItemString(d,"GL_INVALID_VALUE", PyInt_FromLong((long) GL_INVALID_VALUE)); + PyDict_SetItemString(d,"GL_INVERT", PyInt_FromLong((long) GL_INVERT)); + PyDict_SetItemString(d,"GL_KEEP", PyInt_FromLong((long) GL_KEEP)); + PyDict_SetItemString(d,"GL_LEFT", PyInt_FromLong((long) GL_LEFT)); + PyDict_SetItemString(d,"GL_LEQUAL", PyInt_FromLong((long) GL_LEQUAL)); + PyDict_SetItemString(d,"GL_LESS", PyInt_FromLong((long) GL_LESS)); + PyDict_SetItemString(d,"GL_LIGHT0", PyInt_FromLong((long) GL_LIGHT0)); + PyDict_SetItemString(d,"GL_LIGHT1", PyInt_FromLong((long) GL_LIGHT1)); + PyDict_SetItemString(d,"GL_LIGHT2", PyInt_FromLong((long) GL_LIGHT2)); + PyDict_SetItemString(d,"GL_LIGHT3", PyInt_FromLong((long) GL_LIGHT3)); + PyDict_SetItemString(d,"GL_LIGHT4", PyInt_FromLong((long) GL_LIGHT4)); + PyDict_SetItemString(d,"GL_LIGHT5", PyInt_FromLong((long) GL_LIGHT5)); + PyDict_SetItemString(d,"GL_LIGHT6", PyInt_FromLong((long) GL_LIGHT6)); + PyDict_SetItemString(d,"GL_LIGHT7", PyInt_FromLong((long) GL_LIGHT7)); + PyDict_SetItemString(d,"GL_LIGHTING", PyInt_FromLong((long) GL_LIGHTING)); + PyDict_SetItemString(d,"GL_LIGHTING_BIT", PyInt_FromLong((long) GL_LIGHTING_BIT)); + PyDict_SetItemString(d,"GL_LIGHT_MODEL_AMBIENT", PyInt_FromLong((long) GL_LIGHT_MODEL_AMBIENT)); + PyDict_SetItemString(d,"GL_LIGHT_MODEL_LOCAL_VIEWER", PyInt_FromLong((long) GL_LIGHT_MODEL_LOCAL_VIEWER)); + PyDict_SetItemString(d,"GL_LIGHT_MODEL_TWO_SIDE", PyInt_FromLong((long) GL_LIGHT_MODEL_TWO_SIDE)); + PyDict_SetItemString(d,"GL_LINE", PyInt_FromLong((long) GL_LINE)); + PyDict_SetItemString(d,"GL_LINEAR", PyInt_FromLong((long) GL_LINEAR)); + PyDict_SetItemString(d,"GL_LINEAR_ATTENUATION", PyInt_FromLong((long) GL_LINEAR_ATTENUATION)); + PyDict_SetItemString(d,"GL_LINEAR_MIPMAP_LINEAR", PyInt_FromLong((long) GL_LINEAR_MIPMAP_LINEAR)); + PyDict_SetItemString(d,"GL_LINEAR_MIPMAP_NEAREST", PyInt_FromLong((long) GL_LINEAR_MIPMAP_NEAREST)); + PyDict_SetItemString(d,"GL_LINES", PyInt_FromLong((long) GL_LINES)); + PyDict_SetItemString(d,"GL_LINE_BIT", PyInt_FromLong((long) GL_LINE_BIT)); + PyDict_SetItemString(d,"GL_LINE_LOOP", PyInt_FromLong((long) GL_LINE_LOOP)); + PyDict_SetItemString(d,"GL_LINE_RESET_TOKEN", PyInt_FromLong((long) GL_LINE_RESET_TOKEN)); + PyDict_SetItemString(d,"GL_LINE_SMOOTH", PyInt_FromLong((long) GL_LINE_SMOOTH)); + PyDict_SetItemString(d,"GL_LINE_SMOOTH_HINT", PyInt_FromLong((long) GL_LINE_SMOOTH_HINT)); + PyDict_SetItemString(d,"GL_LINE_STIPPLE", PyInt_FromLong((long) GL_LINE_STIPPLE)); + PyDict_SetItemString(d,"GL_LINE_STIPPLE_PATTERN", PyInt_FromLong((long) GL_LINE_STIPPLE_PATTERN)); + PyDict_SetItemString(d,"GL_LINE_STIPPLE_REPEAT", PyInt_FromLong((long) GL_LINE_STIPPLE_REPEAT)); + PyDict_SetItemString(d,"GL_LINE_STRIP", PyInt_FromLong((long) GL_LINE_STRIP)); + PyDict_SetItemString(d,"GL_LINE_TOKEN", PyInt_FromLong((long) GL_LINE_TOKEN)); + PyDict_SetItemString(d,"GL_LINE_WIDTH", PyInt_FromLong((long) GL_LINE_WIDTH)); + PyDict_SetItemString(d,"GL_LINE_WIDTH_GRANULARITY", PyInt_FromLong((long) GL_LINE_WIDTH_GRANULARITY)); + PyDict_SetItemString(d,"GL_LINE_WIDTH_RANGE", PyInt_FromLong((long) GL_LINE_WIDTH_RANGE)); + PyDict_SetItemString(d,"GL_LIST_BASE", PyInt_FromLong((long) GL_LIST_BASE)); + PyDict_SetItemString(d,"GL_LIST_BIT", PyInt_FromLong((long) GL_LIST_BIT)); + PyDict_SetItemString(d,"GL_LIST_INDEX", PyInt_FromLong((long) GL_LIST_INDEX)); + PyDict_SetItemString(d,"GL_LIST_MODE", PyInt_FromLong((long) GL_LIST_MODE)); + PyDict_SetItemString(d,"GL_LOAD", PyInt_FromLong((long) GL_LOAD)); + PyDict_SetItemString(d,"GL_LOGIC_OP", PyInt_FromLong((long) GL_LOGIC_OP)); + PyDict_SetItemString(d,"GL_LOGIC_OP_MODE", PyInt_FromLong((long) GL_LOGIC_OP_MODE)); + PyDict_SetItemString(d,"GL_LUMINANCE", PyInt_FromLong((long) GL_LUMINANCE)); + PyDict_SetItemString(d,"GL_LUMINANCE12", PyInt_FromLong((long) GL_LUMINANCE12)); + PyDict_SetItemString(d,"GL_LUMINANCE12_ALPHA12", PyInt_FromLong((long) GL_LUMINANCE12_ALPHA12)); + PyDict_SetItemString(d,"GL_LUMINANCE12_ALPHA4", PyInt_FromLong((long) GL_LUMINANCE12_ALPHA4)); + PyDict_SetItemString(d,"GL_LUMINANCE16", PyInt_FromLong((long) GL_LUMINANCE16)); + PyDict_SetItemString(d,"GL_LUMINANCE16_ALPHA16", PyInt_FromLong((long) GL_LUMINANCE16_ALPHA16)); + PyDict_SetItemString(d,"GL_LUMINANCE4", PyInt_FromLong((long) GL_LUMINANCE4)); + PyDict_SetItemString(d,"GL_LUMINANCE4_ALPHA4", PyInt_FromLong((long) GL_LUMINANCE4_ALPHA4)); + PyDict_SetItemString(d,"GL_LUMINANCE6_ALPHA2", PyInt_FromLong((long) GL_LUMINANCE6_ALPHA2)); + PyDict_SetItemString(d,"GL_LUMINANCE8", PyInt_FromLong((long) GL_LUMINANCE8)); + PyDict_SetItemString(d,"GL_LUMINANCE8_ALPHA8", PyInt_FromLong((long) GL_LUMINANCE8_ALPHA8)); + PyDict_SetItemString(d,"GL_LUMINANCE_ALPHA", PyInt_FromLong((long) GL_LUMINANCE_ALPHA)); + PyDict_SetItemString(d,"GL_MAP1_COLOR_4", PyInt_FromLong((long) GL_MAP1_COLOR_4)); + PyDict_SetItemString(d,"GL_MAP1_GRID_DOMAIN", PyInt_FromLong((long) GL_MAP1_GRID_DOMAIN)); + PyDict_SetItemString(d,"GL_MAP1_GRID_SEGMENTS", PyInt_FromLong((long) GL_MAP1_GRID_SEGMENTS)); + PyDict_SetItemString(d,"GL_MAP1_INDEX", PyInt_FromLong((long) GL_MAP1_INDEX)); + PyDict_SetItemString(d,"GL_MAP1_NORMAL", PyInt_FromLong((long) GL_MAP1_NORMAL)); + PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_1", PyInt_FromLong((long) GL_MAP1_TEXTURE_COORD_1)); + PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_2", PyInt_FromLong((long) GL_MAP1_TEXTURE_COORD_2)); + PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_3", PyInt_FromLong((long) GL_MAP1_TEXTURE_COORD_3)); + PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_4", PyInt_FromLong((long) GL_MAP1_TEXTURE_COORD_4)); + PyDict_SetItemString(d,"GL_MAP1_VERTEX_3", PyInt_FromLong((long) GL_MAP1_VERTEX_3)); + PyDict_SetItemString(d,"GL_MAP1_VERTEX_4", PyInt_FromLong((long) GL_MAP1_VERTEX_4)); + PyDict_SetItemString(d,"GL_MAP2_COLOR_4", PyInt_FromLong((long) GL_MAP2_COLOR_4)); + PyDict_SetItemString(d,"GL_MAP2_GRID_DOMAIN", PyInt_FromLong((long) GL_MAP2_GRID_DOMAIN)); + PyDict_SetItemString(d,"GL_MAP2_GRID_SEGMENTS", PyInt_FromLong((long) GL_MAP2_GRID_SEGMENTS)); + PyDict_SetItemString(d,"GL_MAP2_INDEX", PyInt_FromLong((long) GL_MAP2_INDEX)); + PyDict_SetItemString(d,"GL_MAP2_NORMAL", PyInt_FromLong((long) GL_MAP2_NORMAL)); + PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_1", PyInt_FromLong((long) GL_MAP2_TEXTURE_COORD_1)); + PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_2", PyInt_FromLong((long) GL_MAP2_TEXTURE_COORD_2)); + PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_3", PyInt_FromLong((long) GL_MAP2_TEXTURE_COORD_3)); + PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_4", PyInt_FromLong((long) GL_MAP2_TEXTURE_COORD_4)); + PyDict_SetItemString(d,"GL_MAP2_VERTEX_3", PyInt_FromLong((long) GL_MAP2_VERTEX_3)); + PyDict_SetItemString(d,"GL_MAP2_VERTEX_4", PyInt_FromLong((long) GL_MAP2_VERTEX_4)); + PyDict_SetItemString(d,"GL_MAP_COLOR", PyInt_FromLong((long) GL_MAP_COLOR)); + PyDict_SetItemString(d,"GL_MAP_STENCIL", PyInt_FromLong((long) GL_MAP_STENCIL)); + PyDict_SetItemString(d,"GL_MATRIX_MODE", PyInt_FromLong((long) GL_MATRIX_MODE)); + PyDict_SetItemString(d,"GL_MAX_ATTRIB_STACK_DEPTH", PyInt_FromLong((long) GL_MAX_ATTRIB_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", PyInt_FromLong((long) GL_MAX_CLIENT_ATTRIB_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_MAX_CLIP_PLANES", PyInt_FromLong((long) GL_MAX_CLIP_PLANES)); + PyDict_SetItemString(d,"GL_MAX_ELEMENTS_INDICES_WIN", PyInt_FromLong((long) GL_MAX_ELEMENTS_INDICES_WIN)); + PyDict_SetItemString(d,"GL_MAX_ELEMENTS_VERTICES_WIN", PyInt_FromLong((long) GL_MAX_ELEMENTS_VERTICES_WIN)); + PyDict_SetItemString(d,"GL_MAX_EVAL_ORDER", PyInt_FromLong((long) GL_MAX_EVAL_ORDER)); + PyDict_SetItemString(d,"GL_MAX_LIGHTS", PyInt_FromLong((long) GL_MAX_LIGHTS)); + PyDict_SetItemString(d,"GL_MAX_LIST_NESTING", PyInt_FromLong((long) GL_MAX_LIST_NESTING)); + PyDict_SetItemString(d,"GL_MAX_MODELVIEW_STACK_DEPTH", PyInt_FromLong((long) GL_MAX_MODELVIEW_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_MAX_NAME_STACK_DEPTH", PyInt_FromLong((long) GL_MAX_NAME_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_MAX_PIXEL_MAP_TABLE", PyInt_FromLong((long) GL_MAX_PIXEL_MAP_TABLE)); + PyDict_SetItemString(d,"GL_MAX_PROJECTION_STACK_DEPTH", PyInt_FromLong((long) GL_MAX_PROJECTION_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_MAX_TEXTURE_SIZE", PyInt_FromLong((long) GL_MAX_TEXTURE_SIZE)); + PyDict_SetItemString(d,"GL_MAX_TEXTURE_STACK_DEPTH", PyInt_FromLong((long) GL_MAX_TEXTURE_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_MAX_VIEWPORT_DIMS", PyInt_FromLong((long) GL_MAX_VIEWPORT_DIMS)); + PyDict_SetItemString(d,"GL_MODELVIEW", PyInt_FromLong((long) GL_MODELVIEW)); + PyDict_SetItemString(d,"GL_MODELVIEW_MATRIX", PyInt_FromLong((long) GL_MODELVIEW_MATRIX)); + PyDict_SetItemString(d,"GL_MODELVIEW_STACK_DEPTH", PyInt_FromLong((long) GL_MODELVIEW_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_MODULATE", PyInt_FromLong((long) GL_MODULATE)); + PyDict_SetItemString(d,"GL_MULT", PyInt_FromLong((long) GL_MULT)); + PyDict_SetItemString(d,"GL_N3F_V3F", PyInt_FromLong((long) GL_N3F_V3F)); + PyDict_SetItemString(d,"GL_NAME_STACK_DEPTH", PyInt_FromLong((long) GL_NAME_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_NAND", PyInt_FromLong((long) GL_NAND)); + PyDict_SetItemString(d,"GL_NEAREST", PyInt_FromLong((long) GL_NEAREST)); + PyDict_SetItemString(d,"GL_NEAREST_MIPMAP_LINEAR", PyInt_FromLong((long) GL_NEAREST_MIPMAP_LINEAR)); + PyDict_SetItemString(d,"GL_NEAREST_MIPMAP_NEAREST", PyInt_FromLong((long) GL_NEAREST_MIPMAP_NEAREST)); + PyDict_SetItemString(d,"GL_NEVER", PyInt_FromLong((long) GL_NEVER)); + PyDict_SetItemString(d,"GL_NICEST", PyInt_FromLong((long) GL_NICEST)); + PyDict_SetItemString(d,"GL_NONE", PyInt_FromLong((long) GL_NONE)); + PyDict_SetItemString(d,"GL_NOOP", PyInt_FromLong((long) GL_NOOP)); + PyDict_SetItemString(d,"GL_NOR", PyInt_FromLong((long) GL_NOR)); + PyDict_SetItemString(d,"GL_NORMALIZE", PyInt_FromLong((long) GL_NORMALIZE)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY", PyInt_FromLong((long) GL_NORMAL_ARRAY)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_COUNT_EXT", PyInt_FromLong((long) GL_NORMAL_ARRAY_COUNT_EXT)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_EXT", PyInt_FromLong((long) GL_NORMAL_ARRAY_EXT)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_POINTER", PyInt_FromLong((long) GL_NORMAL_ARRAY_POINTER)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_POINTER_EXT", PyInt_FromLong((long) GL_NORMAL_ARRAY_POINTER_EXT)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_STRIDE", PyInt_FromLong((long) GL_NORMAL_ARRAY_STRIDE)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_STRIDE_EXT", PyInt_FromLong((long) GL_NORMAL_ARRAY_STRIDE_EXT)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_TYPE", PyInt_FromLong((long) GL_NORMAL_ARRAY_TYPE)); + PyDict_SetItemString(d,"GL_NORMAL_ARRAY_TYPE_EXT", PyInt_FromLong((long) GL_NORMAL_ARRAY_TYPE_EXT)); + PyDict_SetItemString(d,"GL_NOTEQUAL", PyInt_FromLong((long) GL_NOTEQUAL)); + PyDict_SetItemString(d,"GL_NO_ERROR", PyInt_FromLong((long) GL_NO_ERROR)); + PyDict_SetItemString(d,"GL_OBJECT_LINEAR", PyInt_FromLong((long) GL_OBJECT_LINEAR)); + PyDict_SetItemString(d,"GL_OBJECT_PLANE", PyInt_FromLong((long) GL_OBJECT_PLANE)); + PyDict_SetItemString(d,"GL_ONE", PyInt_FromLong((long) GL_ONE)); + PyDict_SetItemString(d,"GL_ONE_MINUS_DST_ALPHA", PyInt_FromLong((long) GL_ONE_MINUS_DST_ALPHA)); + PyDict_SetItemString(d,"GL_ONE_MINUS_DST_COLOR", PyInt_FromLong((long) GL_ONE_MINUS_DST_COLOR)); + PyDict_SetItemString(d,"GL_ONE_MINUS_SRC_ALPHA", PyInt_FromLong((long) GL_ONE_MINUS_SRC_ALPHA)); + PyDict_SetItemString(d,"GL_ONE_MINUS_SRC_COLOR", PyInt_FromLong((long) GL_ONE_MINUS_SRC_COLOR)); + PyDict_SetItemString(d,"GL_OR", PyInt_FromLong((long) GL_OR)); + PyDict_SetItemString(d,"GL_ORDER", PyInt_FromLong((long) GL_ORDER)); + PyDict_SetItemString(d,"GL_OR_INVERTED", PyInt_FromLong((long) GL_OR_INVERTED)); + PyDict_SetItemString(d,"GL_OR_REVERSE", PyInt_FromLong((long) GL_OR_REVERSE)); + PyDict_SetItemString(d,"GL_OUT_OF_MEMORY", PyInt_FromLong((long) GL_OUT_OF_MEMORY)); + PyDict_SetItemString(d,"GL_PACK_ALIGNMENT", PyInt_FromLong((long) GL_PACK_ALIGNMENT)); + PyDict_SetItemString(d,"GL_PACK_LSB_FIRST", PyInt_FromLong((long) GL_PACK_LSB_FIRST)); + PyDict_SetItemString(d,"GL_PACK_ROW_LENGTH", PyInt_FromLong((long) GL_PACK_ROW_LENGTH)); + PyDict_SetItemString(d,"GL_PACK_SKIP_PIXELS", PyInt_FromLong((long) GL_PACK_SKIP_PIXELS)); + PyDict_SetItemString(d,"GL_PACK_SKIP_ROWS", PyInt_FromLong((long) GL_PACK_SKIP_ROWS)); + PyDict_SetItemString(d,"GL_PACK_SWAP_BYTES", PyInt_FromLong((long) GL_PACK_SWAP_BYTES)); + PyDict_SetItemString(d,"GL_PASS_THROUGH_TOKEN", PyInt_FromLong((long) GL_PASS_THROUGH_TOKEN)); + PyDict_SetItemString(d,"GL_PERSPECTIVE_CORRECTION_HINT", PyInt_FromLong((long) GL_PERSPECTIVE_CORRECTION_HINT)); + PyDict_SetItemString(d,"GL_PHONG_HINT_WIN", PyInt_FromLong((long) GL_PHONG_HINT_WIN)); + PyDict_SetItemString(d,"GL_PHONG_WIN", PyInt_FromLong((long) GL_PHONG_WIN)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_A_TO_A", PyInt_FromLong((long) GL_PIXEL_MAP_A_TO_A)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_A_TO_A_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_A_TO_A_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_B_TO_B", PyInt_FromLong((long) GL_PIXEL_MAP_B_TO_B)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_B_TO_B_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_B_TO_B_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_G_TO_G", PyInt_FromLong((long) GL_PIXEL_MAP_G_TO_G)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_G_TO_G_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_G_TO_G_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_A", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_A)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_A_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_A_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_B", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_B)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_B_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_B_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_G", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_G)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_G_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_G_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_I", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_I)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_I_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_I_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_R", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_R)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_R_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_I_TO_R_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_R_TO_R", PyInt_FromLong((long) GL_PIXEL_MAP_R_TO_R)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_R_TO_R_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_R_TO_R_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_S_TO_S", PyInt_FromLong((long) GL_PIXEL_MAP_S_TO_S)); + PyDict_SetItemString(d,"GL_PIXEL_MAP_S_TO_S_SIZE", PyInt_FromLong((long) GL_PIXEL_MAP_S_TO_S_SIZE)); + PyDict_SetItemString(d,"GL_PIXEL_MODE_BIT", PyInt_FromLong((long) GL_PIXEL_MODE_BIT)); + PyDict_SetItemString(d,"GL_POINT", PyInt_FromLong((long) GL_POINT)); + PyDict_SetItemString(d,"GL_POINTS", PyInt_FromLong((long) GL_POINTS)); + PyDict_SetItemString(d,"GL_POINT_BIT", PyInt_FromLong((long) GL_POINT_BIT)); + PyDict_SetItemString(d,"GL_POINT_SIZE", PyInt_FromLong((long) GL_POINT_SIZE)); + PyDict_SetItemString(d,"GL_POINT_SIZE_GRANULARITY", PyInt_FromLong((long) GL_POINT_SIZE_GRANULARITY)); + PyDict_SetItemString(d,"GL_POINT_SIZE_RANGE", PyInt_FromLong((long) GL_POINT_SIZE_RANGE)); + PyDict_SetItemString(d,"GL_POINT_SMOOTH", PyInt_FromLong((long) GL_POINT_SMOOTH)); + PyDict_SetItemString(d,"GL_POINT_SMOOTH_HINT", PyInt_FromLong((long) GL_POINT_SMOOTH_HINT)); + PyDict_SetItemString(d,"GL_POINT_TOKEN", PyInt_FromLong((long) GL_POINT_TOKEN)); + PyDict_SetItemString(d,"GL_POLYGON", PyInt_FromLong((long) GL_POLYGON)); + PyDict_SetItemString(d,"GL_POLYGON_BIT", PyInt_FromLong((long) GL_POLYGON_BIT)); + PyDict_SetItemString(d,"GL_POLYGON_MODE", PyInt_FromLong((long) GL_POLYGON_MODE)); + PyDict_SetItemString(d,"GL_POLYGON_OFFSET_FACTOR", PyInt_FromLong((long) GL_POLYGON_OFFSET_FACTOR)); + PyDict_SetItemString(d,"GL_POLYGON_OFFSET_FILL", PyInt_FromLong((long) GL_POLYGON_OFFSET_FILL)); + PyDict_SetItemString(d,"GL_POLYGON_OFFSET_LINE", PyInt_FromLong((long) GL_POLYGON_OFFSET_LINE)); + PyDict_SetItemString(d,"GL_POLYGON_OFFSET_POINT", PyInt_FromLong((long) GL_POLYGON_OFFSET_POINT)); + PyDict_SetItemString(d,"GL_POLYGON_OFFSET_UNITS", PyInt_FromLong((long) GL_POLYGON_OFFSET_UNITS)); + PyDict_SetItemString(d,"GL_POLYGON_SMOOTH", PyInt_FromLong((long) GL_POLYGON_SMOOTH)); + PyDict_SetItemString(d,"GL_POLYGON_SMOOTH_HINT", PyInt_FromLong((long) GL_POLYGON_SMOOTH_HINT)); + PyDict_SetItemString(d,"GL_POLYGON_STIPPLE", PyInt_FromLong((long) GL_POLYGON_STIPPLE)); + PyDict_SetItemString(d,"GL_POLYGON_STIPPLE_BIT", PyInt_FromLong((long) GL_POLYGON_STIPPLE_BIT)); + PyDict_SetItemString(d,"GL_POLYGON_TOKEN", PyInt_FromLong((long) GL_POLYGON_TOKEN)); + PyDict_SetItemString(d,"GL_POSITION", PyInt_FromLong((long) GL_POSITION)); + PyDict_SetItemString(d,"GL_PROJECTION", PyInt_FromLong((long) GL_PROJECTION)); + PyDict_SetItemString(d,"GL_PROJECTION_MATRIX", PyInt_FromLong((long) GL_PROJECTION_MATRIX)); + PyDict_SetItemString(d,"GL_PROJECTION_STACK_DEPTH", PyInt_FromLong((long) GL_PROJECTION_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_PROXY_TEXTURE_1D", PyInt_FromLong((long) GL_PROXY_TEXTURE_1D)); + PyDict_SetItemString(d,"GL_PROXY_TEXTURE_2D", PyInt_FromLong((long) GL_PROXY_TEXTURE_2D)); + PyDict_SetItemString(d,"GL_Q", PyInt_FromLong((long) GL_Q)); + PyDict_SetItemString(d,"GL_QUADRATIC_ATTENUATION", PyInt_FromLong((long) GL_QUADRATIC_ATTENUATION)); + PyDict_SetItemString(d,"GL_QUADS", PyInt_FromLong((long) GL_QUADS)); + PyDict_SetItemString(d,"GL_QUAD_STRIP", PyInt_FromLong((long) GL_QUAD_STRIP)); + PyDict_SetItemString(d,"GL_R", PyInt_FromLong((long) GL_R)); + PyDict_SetItemString(d,"GL_R3_G3_B2", PyInt_FromLong((long) GL_R3_G3_B2)); + PyDict_SetItemString(d,"GL_READ_BUFFER", PyInt_FromLong((long) GL_READ_BUFFER)); + PyDict_SetItemString(d,"GL_RED", PyInt_FromLong((long) GL_RED)); + PyDict_SetItemString(d,"GL_RED_BIAS", PyInt_FromLong((long) GL_RED_BIAS)); + PyDict_SetItemString(d,"GL_RED_BITS", PyInt_FromLong((long) GL_RED_BITS)); + PyDict_SetItemString(d,"GL_RED_SCALE", PyInt_FromLong((long) GL_RED_SCALE)); + PyDict_SetItemString(d,"GL_RENDER", PyInt_FromLong((long) GL_RENDER)); + PyDict_SetItemString(d,"GL_RENDERER", PyInt_FromLong((long) GL_RENDERER)); + PyDict_SetItemString(d,"GL_RENDER_MODE", PyInt_FromLong((long) GL_RENDER_MODE)); + PyDict_SetItemString(d,"GL_REPEAT", PyInt_FromLong((long) GL_REPEAT)); + PyDict_SetItemString(d,"GL_REPLACE", PyInt_FromLong((long) GL_REPLACE)); + PyDict_SetItemString(d,"GL_RETURN", PyInt_FromLong((long) GL_RETURN)); + PyDict_SetItemString(d,"GL_RGB", PyInt_FromLong((long) GL_RGB)); + PyDict_SetItemString(d,"GL_RGB10", PyInt_FromLong((long) GL_RGB10)); + PyDict_SetItemString(d,"GL_RGB10_A2", PyInt_FromLong((long) GL_RGB10_A2)); + PyDict_SetItemString(d,"GL_RGB12", PyInt_FromLong((long) GL_RGB12)); + PyDict_SetItemString(d,"GL_RGB16", PyInt_FromLong((long) GL_RGB16)); + PyDict_SetItemString(d,"GL_RGB4", PyInt_FromLong((long) GL_RGB4)); + PyDict_SetItemString(d,"GL_RGB5", PyInt_FromLong((long) GL_RGB5)); + PyDict_SetItemString(d,"GL_RGB5_A1", PyInt_FromLong((long) GL_RGB5_A1)); + PyDict_SetItemString(d,"GL_RGB8", PyInt_FromLong((long) GL_RGB8)); + PyDict_SetItemString(d,"GL_RGBA", PyInt_FromLong((long) GL_RGBA)); + PyDict_SetItemString(d,"GL_RGBA12", PyInt_FromLong((long) GL_RGBA12)); + PyDict_SetItemString(d,"GL_RGBA16", PyInt_FromLong((long) GL_RGBA16)); + PyDict_SetItemString(d,"GL_RGBA2", PyInt_FromLong((long) GL_RGBA2)); + PyDict_SetItemString(d,"GL_RGBA4", PyInt_FromLong((long) GL_RGBA4)); + PyDict_SetItemString(d,"GL_RGBA8", PyInt_FromLong((long) GL_RGBA8)); + PyDict_SetItemString(d,"GL_RGBA_MODE", PyInt_FromLong((long) GL_RGBA_MODE)); + PyDict_SetItemString(d,"GL_RIGHT", PyInt_FromLong((long) GL_RIGHT)); + PyDict_SetItemString(d,"GL_S", PyInt_FromLong((long) GL_S)); + PyDict_SetItemString(d,"GL_SCISSOR_BIT", PyInt_FromLong((long) GL_SCISSOR_BIT)); + PyDict_SetItemString(d,"GL_SCISSOR_BOX", PyInt_FromLong((long) GL_SCISSOR_BOX)); + PyDict_SetItemString(d,"GL_SCISSOR_TEST", PyInt_FromLong((long) GL_SCISSOR_TEST)); + PyDict_SetItemString(d,"GL_SELECT", PyInt_FromLong((long) GL_SELECT)); + PyDict_SetItemString(d,"GL_SELECTION_BUFFER_POINTER", PyInt_FromLong((long) GL_SELECTION_BUFFER_POINTER)); + PyDict_SetItemString(d,"GL_SELECTION_BUFFER_SIZE", PyInt_FromLong((long) GL_SELECTION_BUFFER_SIZE)); + PyDict_SetItemString(d,"GL_SET", PyInt_FromLong((long) GL_SET)); + PyDict_SetItemString(d,"GL_SHADE_MODEL", PyInt_FromLong((long) GL_SHADE_MODEL)); + PyDict_SetItemString(d,"GL_SHININESS", PyInt_FromLong((long) GL_SHININESS)); + PyDict_SetItemString(d,"GL_SHORT", PyInt_FromLong((long) GL_SHORT)); + PyDict_SetItemString(d,"GL_SMOOTH", PyInt_FromLong((long) GL_SMOOTH)); + PyDict_SetItemString(d,"GL_SPECULAR", PyInt_FromLong((long) GL_SPECULAR)); + PyDict_SetItemString(d,"GL_SPHERE_MAP", PyInt_FromLong((long) GL_SPHERE_MAP)); + PyDict_SetItemString(d,"GL_SPOT_CUTOFF", PyInt_FromLong((long) GL_SPOT_CUTOFF)); + PyDict_SetItemString(d,"GL_SPOT_DIRECTION", PyInt_FromLong((long) GL_SPOT_DIRECTION)); + PyDict_SetItemString(d,"GL_SPOT_EXPONENT", PyInt_FromLong((long) GL_SPOT_EXPONENT)); + PyDict_SetItemString(d,"GL_SRC_ALPHA", PyInt_FromLong((long) GL_SRC_ALPHA)); + PyDict_SetItemString(d,"GL_SRC_ALPHA_SATURATE", PyInt_FromLong((long) GL_SRC_ALPHA_SATURATE)); + PyDict_SetItemString(d,"GL_SRC_COLOR", PyInt_FromLong((long) GL_SRC_COLOR)); + PyDict_SetItemString(d,"GL_STACK_OVERFLOW", PyInt_FromLong((long) GL_STACK_OVERFLOW)); + PyDict_SetItemString(d,"GL_STACK_UNDERFLOW", PyInt_FromLong((long) GL_STACK_UNDERFLOW)); + PyDict_SetItemString(d,"GL_STENCIL", PyInt_FromLong((long) GL_STENCIL)); + PyDict_SetItemString(d,"GL_STENCIL_BITS", PyInt_FromLong((long) GL_STENCIL_BITS)); + PyDict_SetItemString(d,"GL_STENCIL_BUFFER_BIT", PyInt_FromLong((long) GL_STENCIL_BUFFER_BIT)); + PyDict_SetItemString(d,"GL_STENCIL_CLEAR_VALUE", PyInt_FromLong((long) GL_STENCIL_CLEAR_VALUE)); + PyDict_SetItemString(d,"GL_STENCIL_FAIL", PyInt_FromLong((long) GL_STENCIL_FAIL)); + PyDict_SetItemString(d,"GL_STENCIL_FUNC", PyInt_FromLong((long) GL_STENCIL_FUNC)); + PyDict_SetItemString(d,"GL_STENCIL_INDEX", PyInt_FromLong((long) GL_STENCIL_INDEX)); + PyDict_SetItemString(d,"GL_STENCIL_PASS_DEPTH_FAIL", PyInt_FromLong((long) GL_STENCIL_PASS_DEPTH_FAIL)); + PyDict_SetItemString(d,"GL_STENCIL_PASS_DEPTH_PASS", PyInt_FromLong((long) GL_STENCIL_PASS_DEPTH_PASS)); + PyDict_SetItemString(d,"GL_STENCIL_REF", PyInt_FromLong((long) GL_STENCIL_REF)); + PyDict_SetItemString(d,"GL_STENCIL_TEST", PyInt_FromLong((long) GL_STENCIL_TEST)); + PyDict_SetItemString(d,"GL_STENCIL_VALUE_MASK", PyInt_FromLong((long) GL_STENCIL_VALUE_MASK)); + PyDict_SetItemString(d,"GL_STENCIL_WRITEMASK", PyInt_FromLong((long) GL_STENCIL_WRITEMASK)); + PyDict_SetItemString(d,"GL_STEREO", PyInt_FromLong((long) GL_STEREO)); + PyDict_SetItemString(d,"GL_SUBPIXEL_BITS", PyInt_FromLong((long) GL_SUBPIXEL_BITS)); + PyDict_SetItemString(d,"GL_T", PyInt_FromLong((long) GL_T)); + PyDict_SetItemString(d,"GL_T2F_C3F_V3F", PyInt_FromLong((long) GL_T2F_C3F_V3F)); + PyDict_SetItemString(d,"GL_T2F_C4F_N3F_V3F", PyInt_FromLong((long) GL_T2F_C4F_N3F_V3F)); + PyDict_SetItemString(d,"GL_T2F_C4UB_V3F", PyInt_FromLong((long) GL_T2F_C4UB_V3F)); + PyDict_SetItemString(d,"GL_T2F_N3F_V3F", PyInt_FromLong((long) GL_T2F_N3F_V3F)); + PyDict_SetItemString(d,"GL_T2F_V3F", PyInt_FromLong((long) GL_T2F_V3F)); + PyDict_SetItemString(d,"GL_T4F_C4F_N3F_V4F", PyInt_FromLong((long) GL_T4F_C4F_N3F_V4F)); + PyDict_SetItemString(d,"GL_T4F_V4F", PyInt_FromLong((long) GL_T4F_V4F)); + PyDict_SetItemString(d,"GL_TEXTURE", PyInt_FromLong((long) GL_TEXTURE)); + PyDict_SetItemString(d,"GL_TEXTURE_1D", PyInt_FromLong((long) GL_TEXTURE_1D)); + PyDict_SetItemString(d,"GL_TEXTURE_2D", PyInt_FromLong((long) GL_TEXTURE_2D)); + PyDict_SetItemString(d,"GL_TEXTURE_ALPHA_SIZE", PyInt_FromLong((long) GL_TEXTURE_ALPHA_SIZE)); + PyDict_SetItemString(d,"GL_TEXTURE_BINDING_1D", PyInt_FromLong((long) GL_TEXTURE_BINDING_1D)); + PyDict_SetItemString(d,"GL_TEXTURE_BINDING_2D", PyInt_FromLong((long) GL_TEXTURE_BINDING_2D)); + PyDict_SetItemString(d,"GL_TEXTURE_BIT", PyInt_FromLong((long) GL_TEXTURE_BIT)); + PyDict_SetItemString(d,"GL_TEXTURE_BLUE_SIZE", PyInt_FromLong((long) GL_TEXTURE_BLUE_SIZE)); + PyDict_SetItemString(d,"GL_TEXTURE_BORDER", PyInt_FromLong((long) GL_TEXTURE_BORDER)); + PyDict_SetItemString(d,"GL_TEXTURE_BORDER_COLOR", PyInt_FromLong((long) GL_TEXTURE_BORDER_COLOR)); + PyDict_SetItemString(d,"GL_TEXTURE_COMPONENTS", PyInt_FromLong((long) GL_TEXTURE_COMPONENTS)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_COUNT_EXT", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_COUNT_EXT)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_EXT", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_EXT)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_POINTER", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_POINTER)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_POINTER_EXT", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_POINTER_EXT)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_SIZE", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_SIZE)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_SIZE_EXT", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_SIZE_EXT)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_STRIDE", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_STRIDE)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_STRIDE_EXT", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_STRIDE_EXT)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_TYPE", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_TYPE)); + PyDict_SetItemString(d,"GL_TEXTURE_COORD_ARRAY_TYPE_EXT", PyInt_FromLong((long) GL_TEXTURE_COORD_ARRAY_TYPE_EXT)); + PyDict_SetItemString(d,"GL_TEXTURE_ENV", PyInt_FromLong((long) GL_TEXTURE_ENV)); + PyDict_SetItemString(d,"GL_TEXTURE_ENV_COLOR", PyInt_FromLong((long) GL_TEXTURE_ENV_COLOR)); + PyDict_SetItemString(d,"GL_TEXTURE_ENV_MODE", PyInt_FromLong((long) GL_TEXTURE_ENV_MODE)); + PyDict_SetItemString(d,"GL_TEXTURE_GEN_MODE", PyInt_FromLong((long) GL_TEXTURE_GEN_MODE)); + PyDict_SetItemString(d,"GL_TEXTURE_GEN_Q", PyInt_FromLong((long) GL_TEXTURE_GEN_Q)); + PyDict_SetItemString(d,"GL_TEXTURE_GEN_R", PyInt_FromLong((long) GL_TEXTURE_GEN_R)); + PyDict_SetItemString(d,"GL_TEXTURE_GEN_S", PyInt_FromLong((long) GL_TEXTURE_GEN_S)); + PyDict_SetItemString(d,"GL_TEXTURE_GEN_T", PyInt_FromLong((long) GL_TEXTURE_GEN_T)); + PyDict_SetItemString(d,"GL_TEXTURE_GREEN_SIZE", PyInt_FromLong((long) GL_TEXTURE_GREEN_SIZE)); + PyDict_SetItemString(d,"GL_TEXTURE_HEIGHT", PyInt_FromLong((long) GL_TEXTURE_HEIGHT)); + PyDict_SetItemString(d,"GL_TEXTURE_INTENSITY_SIZE", PyInt_FromLong((long) GL_TEXTURE_INTENSITY_SIZE)); + PyDict_SetItemString(d,"GL_TEXTURE_INTERNAL_FORMAT", PyInt_FromLong((long) GL_TEXTURE_INTERNAL_FORMAT)); + PyDict_SetItemString(d,"GL_TEXTURE_LUMINANCE_SIZE", PyInt_FromLong((long) GL_TEXTURE_LUMINANCE_SIZE)); + PyDict_SetItemString(d,"GL_TEXTURE_MAG_FILTER", PyInt_FromLong((long) GL_TEXTURE_MAG_FILTER)); + PyDict_SetItemString(d,"GL_TEXTURE_MATRIX", PyInt_FromLong((long) GL_TEXTURE_MATRIX)); + PyDict_SetItemString(d,"GL_TEXTURE_MIN_FILTER", PyInt_FromLong((long) GL_TEXTURE_MIN_FILTER)); + PyDict_SetItemString(d,"GL_TEXTURE_PRIORITY", PyInt_FromLong((long) GL_TEXTURE_PRIORITY)); + PyDict_SetItemString(d,"GL_TEXTURE_RED_SIZE", PyInt_FromLong((long) GL_TEXTURE_RED_SIZE)); + PyDict_SetItemString(d,"GL_TEXTURE_RESIDENT", PyInt_FromLong((long) GL_TEXTURE_RESIDENT)); + PyDict_SetItemString(d,"GL_TEXTURE_STACK_DEPTH", PyInt_FromLong((long) GL_TEXTURE_STACK_DEPTH)); + PyDict_SetItemString(d,"GL_TEXTURE_WIDTH", PyInt_FromLong((long) GL_TEXTURE_WIDTH)); + PyDict_SetItemString(d,"GL_TEXTURE_WRAP_S", PyInt_FromLong((long) GL_TEXTURE_WRAP_S)); + PyDict_SetItemString(d,"GL_TEXTURE_WRAP_T", PyInt_FromLong((long) GL_TEXTURE_WRAP_T)); + PyDict_SetItemString(d,"GL_TRANSFORM_BIT", PyInt_FromLong((long) GL_TRANSFORM_BIT)); + PyDict_SetItemString(d,"GL_TRIANGLES", PyInt_FromLong((long) GL_TRIANGLES)); + PyDict_SetItemString(d,"GL_TRIANGLE_FAN", PyInt_FromLong((long) GL_TRIANGLE_FAN)); + PyDict_SetItemString(d,"GL_TRIANGLE_STRIP", PyInt_FromLong((long) GL_TRIANGLE_STRIP)); + PyDict_SetItemString(d,"GL_TRUE", PyInt_FromLong((long) GL_TRUE)); + PyDict_SetItemString(d,"GL_UNPACK_ALIGNMENT", PyInt_FromLong((long) GL_UNPACK_ALIGNMENT)); + PyDict_SetItemString(d,"GL_UNPACK_LSB_FIRST", PyInt_FromLong((long) GL_UNPACK_LSB_FIRST)); + PyDict_SetItemString(d,"GL_UNPACK_ROW_LENGTH", PyInt_FromLong((long) GL_UNPACK_ROW_LENGTH)); + PyDict_SetItemString(d,"GL_UNPACK_SKIP_PIXELS", PyInt_FromLong((long) GL_UNPACK_SKIP_PIXELS)); + PyDict_SetItemString(d,"GL_UNPACK_SKIP_ROWS", PyInt_FromLong((long) GL_UNPACK_SKIP_ROWS)); + PyDict_SetItemString(d,"GL_UNPACK_SWAP_BYTES", PyInt_FromLong((long) GL_UNPACK_SWAP_BYTES)); + PyDict_SetItemString(d,"GL_UNSIGNED_BYTE", PyInt_FromLong((long) GL_UNSIGNED_BYTE)); + PyDict_SetItemString(d,"GL_UNSIGNED_INT", PyInt_FromLong((long) GL_UNSIGNED_INT)); + PyDict_SetItemString(d,"GL_UNSIGNED_SHORT", PyInt_FromLong((long) GL_UNSIGNED_SHORT)); + PyDict_SetItemString(d,"GL_V2F", PyInt_FromLong((long) GL_V2F)); + PyDict_SetItemString(d,"GL_V3F", PyInt_FromLong((long) GL_V3F)); + PyDict_SetItemString(d,"GL_VENDOR", PyInt_FromLong((long) GL_VENDOR)); + PyDict_SetItemString(d,"GL_VERSION", PyInt_FromLong((long) GL_VERSION)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY", PyInt_FromLong((long) GL_VERTEX_ARRAY)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_COUNT_EXT", PyInt_FromLong((long) GL_VERTEX_ARRAY_COUNT_EXT)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_EXT", PyInt_FromLong((long) GL_VERTEX_ARRAY_EXT)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_POINTER", PyInt_FromLong((long) GL_VERTEX_ARRAY_POINTER)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_POINTER_EXT", PyInt_FromLong((long) GL_VERTEX_ARRAY_POINTER_EXT)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_SIZE", PyInt_FromLong((long) GL_VERTEX_ARRAY_SIZE)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_SIZE_EXT", PyInt_FromLong((long) GL_VERTEX_ARRAY_SIZE_EXT)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_STRIDE", PyInt_FromLong((long) GL_VERTEX_ARRAY_STRIDE)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_STRIDE_EXT", PyInt_FromLong((long) GL_VERTEX_ARRAY_STRIDE_EXT)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_TYPE", PyInt_FromLong((long) GL_VERTEX_ARRAY_TYPE)); + PyDict_SetItemString(d,"GL_VERTEX_ARRAY_TYPE_EXT", PyInt_FromLong((long) GL_VERTEX_ARRAY_TYPE_EXT)); + PyDict_SetItemString(d,"GL_VIEWPORT", PyInt_FromLong((long) GL_VIEWPORT)); + PyDict_SetItemString(d,"GL_VIEWPORT_BIT", PyInt_FromLong((long) GL_VIEWPORT_BIT)); + PyDict_SetItemString(d,"GL_WIN_draw_range_elements", PyInt_FromLong((long) GL_WIN_draw_range_elements)); + PyDict_SetItemString(d,"GL_WIN_swap_hint", PyInt_FromLong((long) GL_WIN_swap_hint)); + PyDict_SetItemString(d,"GL_XOR", PyInt_FromLong((long) GL_XOR)); + PyDict_SetItemString(d,"GL_ZERO", PyInt_FromLong((long) GL_ZERO)); + PyDict_SetItemString(d,"GL_ZOOM_X", PyInt_FromLong((long) GL_ZOOM_X)); + PyDict_SetItemString(d,"GL_ZOOM_Y", PyInt_FromLong((long) GL_ZOOM_Y)); +/* + * These are the pointer type-equivalency mappings. + * (Used by the SWIG pointer type-checker). + */ + SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0); + SWIG_RegisterMapping("_wxEvent","_class_wxEvent",0); + SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0); + SWIG_RegisterMapping("_GLfloat","_GLclampf",0); + SWIG_RegisterMapping("_GLfloat","_float",0); + SWIG_RegisterMapping("_signed_long","_long",0); + SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0); + SWIG_RegisterMapping("_double","_GLclampd",0); + SWIG_RegisterMapping("_double","_GLdouble",0); + SWIG_RegisterMapping("_wxFontData","_class_wxFontData",0); + SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0); + SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0); + SWIG_RegisterMapping("_class_wxPyTreeItemData","_wxPyTreeItemData",0); + SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxGLCanvas",SwigwxGLCanvasTowxEvtHandler); + SWIG_RegisterMapping("_class_wxEvtHandler","_wxGLCanvas",SwigwxGLCanvasTowxEvtHandler); + SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0); + SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0); + SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0); + SWIG_RegisterMapping("_GLsizei","_GLuint",0); + SWIG_RegisterMapping("_GLsizei","_int",0); + SWIG_RegisterMapping("_GLsizei","_signed_int",0); + SWIG_RegisterMapping("_GLsizei","_unsigned_int",0); + SWIG_RegisterMapping("_GLsizei","_wxWindowID",0); + SWIG_RegisterMapping("_GLsizei","_uint",0); + SWIG_RegisterMapping("_GLsizei","_EBool",0); + SWIG_RegisterMapping("_GLsizei","_GLenum",0); + SWIG_RegisterMapping("_GLsizei","_GLbitfield",0); + SWIG_RegisterMapping("_GLsizei","_GLint",0); + SWIG_RegisterMapping("_class_wxTreeCtrl","_wxTreeCtrl",0); + SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0); + SWIG_RegisterMapping("_wxMask","_class_wxMask",0); + SWIG_RegisterMapping("_wxGrid","_class_wxGrid",0); + SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0); + SWIG_RegisterMapping("_class_wxColourData","_wxColourData",0); + SWIG_RegisterMapping("_class_wxPageSetupDialogData","_wxPageSetupDialogData",0); + SWIG_RegisterMapping("_GLbyte","_signed_char",0); + SWIG_RegisterMapping("_wxPen","_class_wxPen",0); + SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0); + SWIG_RegisterMapping("_byte","_GLubyte",0); + SWIG_RegisterMapping("_byte","_GLboolean",0); + SWIG_RegisterMapping("_byte","_unsigned_char",0); + SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0); + SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0); + SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0); + SWIG_RegisterMapping("_wxNotebookEvent","_class_wxNotebookEvent",0); + SWIG_RegisterMapping("_long","_wxDash",0); + SWIG_RegisterMapping("_long","_unsigned_long",0); + SWIG_RegisterMapping("_long","_signed_long",0); + SWIG_RegisterMapping("_wxImageList","_class_wxImageList",0); + SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0); + SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0); + SWIG_RegisterMapping("_wxSashWindow","_class_wxSashWindow",0); + SWIG_RegisterMapping("_GLenum","_GLuint",0); + SWIG_RegisterMapping("_GLenum","_GLsizei",0); + SWIG_RegisterMapping("_GLenum","_GLint",0); + SWIG_RegisterMapping("_GLenum","_GLbitfield",0); + SWIG_RegisterMapping("_GLenum","_unsigned_int",0); + SWIG_RegisterMapping("_GLenum","_int",0); + SWIG_RegisterMapping("_GLenum","_wxWindowID",0); + SWIG_RegisterMapping("_GLenum","_uint",0); + SWIG_RegisterMapping("_class_wxPrintDialogData","_wxPrintDialogData",0); + SWIG_RegisterMapping("_wxGLContext","_class_wxGLContext",0); + SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0); + SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0); + SWIG_RegisterMapping("_class_wxSashEvent","_wxSashEvent",0); + SWIG_RegisterMapping("_float","_GLclampf",0); + SWIG_RegisterMapping("_float","_GLfloat",0); + SWIG_RegisterMapping("_wxDC","_class_wxDC",0); + SWIG_RegisterMapping("_wxListEvent","_class_wxListEvent",0); + SWIG_RegisterMapping("_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0); + SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0); + SWIG_RegisterMapping("_wxSashLayoutWindow","_class_wxSashLayoutWindow",0); + SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0); + SWIG_RegisterMapping("_wxPrinterDC","_class_wxPrinterDC",0); + SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0); + SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0); + SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0); + SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0); + SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); + SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); + SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); + SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); + SWIG_RegisterMapping("_signed_char","_GLbyte",0); + SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); + SWIG_RegisterMapping("_class_wxMask","_wxMask",0); + SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0); + SWIG_RegisterMapping("_class_wxGrid","_wxGrid",0); + SWIG_RegisterMapping("_wxColour","_class_wxColour",0); + SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0); + SWIG_RegisterMapping("_wxPageSetupDialog","_class_wxPageSetupDialog",0); + SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0); + SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0); + SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0); + SWIG_RegisterMapping("_class_wxLayoutAlgorithm","_wxLayoutAlgorithm",0); + SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0); + SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0); + SWIG_RegisterMapping("_class_wxNotebookEvent","_wxNotebookEvent",0); + SWIG_RegisterMapping("_class_wxSashWindow","_wxSashWindow",0); + SWIG_RegisterMapping("_GLuint","_unsigned_int",0); + SWIG_RegisterMapping("_GLuint","_int",0); + SWIG_RegisterMapping("_GLuint","_wxWindowID",0); + SWIG_RegisterMapping("_GLuint","_uint",0); + SWIG_RegisterMapping("_GLuint","_GLenum",0); + SWIG_RegisterMapping("_GLuint","_GLbitfield",0); + SWIG_RegisterMapping("_GLuint","_GLint",0); + SWIG_RegisterMapping("_GLuint","_GLsizei",0); + SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0); + SWIG_RegisterMapping("_uint","_GLuint",0); + SWIG_RegisterMapping("_uint","_GLsizei",0); + SWIG_RegisterMapping("_uint","_GLint",0); + SWIG_RegisterMapping("_uint","_GLbitfield",0); + SWIG_RegisterMapping("_uint","_GLenum",0); + SWIG_RegisterMapping("_uint","_unsigned_int",0); + SWIG_RegisterMapping("_uint","_int",0); + SWIG_RegisterMapping("_uint","_wxWindowID",0); + SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0); + SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0); + SWIG_RegisterMapping("_wxGridEvent","_class_wxGridEvent",0); + SWIG_RegisterMapping("_wxRect","_class_wxRect",0); + SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0); + SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0); + SWIG_RegisterMapping("_GLclampd","_double",0); + SWIG_RegisterMapping("_GLclampd","_GLdouble",0); + SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0); + SWIG_RegisterMapping("_class_wxSashLayoutWindow","_wxSashLayoutWindow",0); + SWIG_RegisterMapping("_class_wxButton","_wxButton",0); + SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0); + SWIG_RegisterMapping("_class_wxFontData","_wxFontData",0); + SWIG_RegisterMapping("_GLclampf","_float",0); + SWIG_RegisterMapping("_GLclampf","_GLfloat",0); + SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0); + SWIG_RegisterMapping("_wxTaskBarIcon","_class_wxTaskBarIcon",0); + SWIG_RegisterMapping("_wxPrintDialog","_class_wxPrintDialog",0); + SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0); + SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0); + SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0); + SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); + SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0); + SWIG_RegisterMapping("_wxColourDialog","_class_wxColourDialog",0); + SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_wxMessageDialog","_class_wxMessageDialog",0); + SWIG_RegisterMapping("_GLbitfield","_GLuint",0); + SWIG_RegisterMapping("_GLbitfield","_GLsizei",0); + SWIG_RegisterMapping("_GLbitfield","_GLint",0); + SWIG_RegisterMapping("_GLbitfield","_unsigned_int",0); + SWIG_RegisterMapping("_GLbitfield","_int",0); + SWIG_RegisterMapping("_GLbitfield","_wxWindowID",0); + SWIG_RegisterMapping("_GLbitfield","_uint",0); + SWIG_RegisterMapping("_GLbitfield","_GLenum",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); + SWIG_RegisterMapping("_wxTextEntryDialog","_class_wxTextEntryDialog",0); + SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); + SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); + SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0); + SWIG_RegisterMapping("_wxListItem","_class_wxListItem",0); + SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0); + SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0); + SWIG_RegisterMapping("_wxCalculateLayoutEvent","_class_wxCalculateLayoutEvent",0); + SWIG_RegisterMapping("_EBool","_GLsizei",0); + SWIG_RegisterMapping("_EBool","_GLint",0); + SWIG_RegisterMapping("_EBool","_signed_int",0); + SWIG_RegisterMapping("_EBool","_int",0); + SWIG_RegisterMapping("_EBool","_wxWindowID",0); + SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0); + SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0); + SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0); + SWIG_RegisterMapping("_wxFont","_class_wxFont",0); + SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0); + SWIG_RegisterMapping("_wxNotebook","_class_wxNotebook",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("_wxPyApp","_class_wxPyApp",0); + SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0); + SWIG_RegisterMapping("_class_wxTreeEvent","_wxTreeEvent",0); + SWIG_RegisterMapping("_class_wxDirDialog","_wxDirDialog",0); + SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0); + SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0); + SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0); + SWIG_RegisterMapping("_class_wxSpinButton","_wxSpinButton",0); + SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0); + SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0); + SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0); + SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0); + SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0); + SWIG_RegisterMapping("_class_wxMessageDialog","_wxMessageDialog",0); + SWIG_RegisterMapping("_signed_int","_GLsizei",0); + SWIG_RegisterMapping("_signed_int","_GLint",0); + SWIG_RegisterMapping("_signed_int","_EBool",0); + SWIG_RegisterMapping("_signed_int","_wxWindowID",0); + SWIG_RegisterMapping("_signed_int","_int",0); + SWIG_RegisterMapping("_class_wxTextCtrl","_wxTextCtrl",0); + SWIG_RegisterMapping("_GLboolean","_GLubyte",0); + SWIG_RegisterMapping("_GLboolean","_unsigned_char",0); + SWIG_RegisterMapping("_GLboolean","_byte",0); + SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0); + SWIG_RegisterMapping("_wxMetaFileDC","_class_wxMetaFileDC",0); + SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0); + SWIG_RegisterMapping("_class_wxMoveEvent","_wxMoveEvent",0); + SWIG_RegisterMapping("_wxListBox","_class_wxListBox",0); + SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0); + SWIG_RegisterMapping("_class_wxMDIChildFrame","_wxMDIChildFrame",0); + SWIG_RegisterMapping("_WXTYPE","_GLushort",0); + SWIG_RegisterMapping("_WXTYPE","_GLshort",0); + SWIG_RegisterMapping("_WXTYPE","_short",0); + SWIG_RegisterMapping("_WXTYPE","_signed_short",0); + SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0); + SWIG_RegisterMapping("_wxFileDialog","_class_wxFileDialog",0); + SWIG_RegisterMapping("_GLshort","_GLushort",0); + SWIG_RegisterMapping("_GLshort","_short",0); + SWIG_RegisterMapping("_GLshort","_signed_short",0); + SWIG_RegisterMapping("_GLshort","_unsigned_short",0); + SWIG_RegisterMapping("_GLshort","_WXTYPE",0); + SWIG_RegisterMapping("_class_wxMDIClientWindow","_wxMDIClientWindow",0); + SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0); + SWIG_RegisterMapping("_unsigned_short","_GLushort",0); + SWIG_RegisterMapping("_unsigned_short","_GLshort",0); + SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0); + SWIG_RegisterMapping("_unsigned_short","_short",0); + SWIG_RegisterMapping("_class_wxWindow","_class_wxGLCanvas",SwigwxGLCanvasTowxWindow); + SWIG_RegisterMapping("_class_wxWindow","_wxGLCanvas",SwigwxGLCanvasTowxWindow); + SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0); + SWIG_RegisterMapping("_wxSplitterWindow","_class_wxSplitterWindow",0); + SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0); + SWIG_RegisterMapping("_wxPrintDialogData","_class_wxPrintDialogData",0); + SWIG_RegisterMapping("_GLushort","_unsigned_short",0); + SWIG_RegisterMapping("_GLushort","_short",0); + SWIG_RegisterMapping("_GLushort","_WXTYPE",0); + SWIG_RegisterMapping("_GLushort","_GLshort",0); + SWIG_RegisterMapping("_class_wxFont","_wxFont",0); + SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0); + SWIG_RegisterMapping("_wxSashEvent","_class_wxSashEvent",0); + SWIG_RegisterMapping("_class_wxMenuEvent","_wxMenuEvent",0); + SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0); + SWIG_RegisterMapping("_wxMouseEvent","_class_wxMouseEvent",0); + SWIG_RegisterMapping("_wxListCtrl","_class_wxListCtrl",0); + SWIG_RegisterMapping("_wxSingleChoiceDialog","_class_wxSingleChoiceDialog",0); + SWIG_RegisterMapping("_wxGLCanvas","_class_wxGLCanvas",0); + SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0); + SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0); + SWIG_RegisterMapping("_class_wxRadioBox","_wxRadioBox",0); + SWIG_RegisterMapping("_wxGridCell","_class_wxGridCell",0); + SWIG_RegisterMapping("_signed_short","_GLshort",0); + SWIG_RegisterMapping("_signed_short","_WXTYPE",0); + SWIG_RegisterMapping("_signed_short","_short",0); + SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0); + SWIG_RegisterMapping("_class_wxTaskBarIcon","_wxTaskBarIcon",0); + SWIG_RegisterMapping("_class_wxPrintDialog","_wxPrintDialog",0); + SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0); + SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0); + SWIG_RegisterMapping("_class_wxFocusEvent","_wxFocusEvent",0); + SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0); + SWIG_RegisterMapping("_wxStatusBar","_class_wxStatusBar",0); + SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0); + SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0); + SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0); + SWIG_RegisterMapping("_wxScrolledWindow","_class_wxGLCanvas",SwigwxGLCanvasTowxScrolledWindow); + SWIG_RegisterMapping("_wxScrolledWindow","_wxGLCanvas",SwigwxGLCanvasTowxScrolledWindow); + SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0); + SWIG_RegisterMapping("_wxTreeItemId","_class_wxTreeItemId",0); + SWIG_RegisterMapping("_unsigned_char","_GLubyte",0); + SWIG_RegisterMapping("_unsigned_char","_GLboolean",0); + SWIG_RegisterMapping("_unsigned_char","_byte",0); + SWIG_RegisterMapping("_class_wxMetaFileDC","_wxMetaFileDC",0); + SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0); + SWIG_RegisterMapping("_wxControl","_class_wxControl",0); + SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0); + SWIG_RegisterMapping("_unsigned_int","_GLuint",0); + SWIG_RegisterMapping("_unsigned_int","_GLsizei",0); + SWIG_RegisterMapping("_unsigned_int","_GLint",0); + SWIG_RegisterMapping("_unsigned_int","_GLbitfield",0); + SWIG_RegisterMapping("_unsigned_int","_GLenum",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_wxListItem","_wxListItem",0); + SWIG_RegisterMapping("_GLdouble","_GLclampd",0); + SWIG_RegisterMapping("_GLdouble","_double",0); + SWIG_RegisterMapping("_class_wxPen","_wxPen",0); + SWIG_RegisterMapping("_class_wxFileDialog","_wxFileDialog",0); + SWIG_RegisterMapping("_wxQueryLayoutInfoEvent","_class_wxQueryLayoutInfoEvent",0); + SWIG_RegisterMapping("_short","_GLushort",0); + SWIG_RegisterMapping("_short","_GLshort",0); + SWIG_RegisterMapping("_short","_WXTYPE",0); + SWIG_RegisterMapping("_short","_unsigned_short",0); + SWIG_RegisterMapping("_short","_signed_short",0); + SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0); + SWIG_RegisterMapping("_wxLayoutAlgorithm","_class_wxLayoutAlgorithm",0); + SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0); + SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0); + SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0); + SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0); + SWIG_RegisterMapping("_class_wxCalculateLayoutEvent","_wxCalculateLayoutEvent",0); + SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0); + SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0); + SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0); + SWIG_RegisterMapping("_class_wxGLContext","_wxGLContext",0); + SWIG_RegisterMapping("_class_wxNotebook","_wxNotebook",0); + SWIG_RegisterMapping("_wxWindowID","_GLuint",0); + SWIG_RegisterMapping("_wxWindowID","_GLsizei",0); + SWIG_RegisterMapping("_wxWindowID","_GLint",0); + SWIG_RegisterMapping("_wxWindowID","_GLbitfield",0); + SWIG_RegisterMapping("_wxWindowID","_GLenum",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","_GLuint",0); + SWIG_RegisterMapping("_int","_GLsizei",0); + SWIG_RegisterMapping("_int","_GLint",0); + SWIG_RegisterMapping("_int","_GLbitfield",0); + SWIG_RegisterMapping("_int","_GLenum",0); + SWIG_RegisterMapping("_int","_EBool",0); + SWIG_RegisterMapping("_int","_uint",0); + SWIG_RegisterMapping("_int","_wxWindowID",0); + SWIG_RegisterMapping("_int","_unsigned_int",0); + SWIG_RegisterMapping("_int","_signed_int",0); + SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0); + SWIG_RegisterMapping("_class_wxListEvent","_wxListEvent",0); + SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0); + SWIG_RegisterMapping("_wxButton","_class_wxButton",0); + SWIG_RegisterMapping("_class_wxPyApp","_wxPyApp",0); + SWIG_RegisterMapping("_wxSize","_class_wxSize",0); + SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0); + SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",0); + SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0); + SWIG_RegisterMapping("_wxPyTreeItemData","_class_wxPyTreeItemData",0); + SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0); + SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0); + SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0); + SWIG_RegisterMapping("_class_wxComboBox","_wxComboBox",0); + SWIG_RegisterMapping("_class_wxRadioButton","_wxRadioButton",0); + SWIG_RegisterMapping("_class_wxTreeItemId","_wxTreeItemId",0); + SWIG_RegisterMapping("_wxTreeCtrl","_class_wxTreeCtrl",0); + SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0); + SWIG_RegisterMapping("_wxIconizeEvent","_class_wxIconizeEvent",0); + SWIG_RegisterMapping("_class_wxControl","_wxControl",0); + SWIG_RegisterMapping("_wxStaticBitmap","_class_wxStaticBitmap",0); + SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0); + SWIG_RegisterMapping("_class_wxColour","_wxColour",0); + SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0); + SWIG_RegisterMapping("_class_wxPageSetupDialog","_wxPageSetupDialog",0); + SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0); + SWIG_RegisterMapping("_class_wxIdleEvent","_wxIdleEvent",0); + SWIG_RegisterMapping("_wxEraseEvent","_class_wxEraseEvent",0); + SWIG_RegisterMapping("_class_wxJoystickEvent","_wxJoystickEvent",0); + SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0); + SWIG_RegisterMapping("_wxFontDialog","_class_wxFontDialog",0); + SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0); + SWIG_RegisterMapping("_class_wxSplitterWindow","_wxSplitterWindow",0); + SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0); + SWIG_RegisterMapping("_GLint","_GLuint",0); + SWIG_RegisterMapping("_GLint","_GLsizei",0); + SWIG_RegisterMapping("_GLint","_int",0); + SWIG_RegisterMapping("_GLint","_signed_int",0); + SWIG_RegisterMapping("_GLint","_unsigned_int",0); + SWIG_RegisterMapping("_GLint","_wxWindowID",0); + SWIG_RegisterMapping("_GLint","_uint",0); + SWIG_RegisterMapping("_GLint","_EBool",0); + SWIG_RegisterMapping("_GLint","_GLenum",0); + SWIG_RegisterMapping("_GLint","_GLbitfield",0); + SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0); + SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0); + SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0); + SWIG_RegisterMapping("_class_wxGridEvent","_wxGridEvent",0); + SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0); + SWIG_RegisterMapping("_GLubyte","_unsigned_char",0); + SWIG_RegisterMapping("_GLubyte","_byte",0); + SWIG_RegisterMapping("_GLubyte","_GLboolean",0); + SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0); + SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0); + SWIG_RegisterMapping("_class_wxListCtrl","_wxListCtrl",0); + SWIG_RegisterMapping("_class_wxGLCanvas","_wxGLCanvas",0); + SWIG_RegisterMapping("_class_wxGridCell","_wxGridCell",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("_wxTreeEvent","_class_wxTreeEvent",0); + SWIG_RegisterMapping("_wxDirDialog","_class_wxDirDialog",0); + SWIG_RegisterMapping("_wxEvtHandler","_class_wxGLCanvas",SwigwxGLCanvasTowxEvtHandler); + SWIG_RegisterMapping("_wxEvtHandler","_wxGLCanvas",SwigwxGLCanvasTowxEvtHandler); + SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0); + SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0); + SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0); + SWIG_RegisterMapping("_class_wxColourDialog","_wxColourDialog",0); + SWIG_RegisterMapping("_wxDash","_unsigned_long",0); + SWIG_RegisterMapping("_wxDash","_long",0); + SWIG_RegisterMapping("_class_wxScrolledWindow","_class_wxGLCanvas",SwigwxGLCanvasTowxScrolledWindow); + SWIG_RegisterMapping("_class_wxScrolledWindow","_wxGLCanvas",SwigwxGLCanvasTowxScrolledWindow); + SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0); + SWIG_RegisterMapping("_class_wxTextEntryDialog","_wxTextEntryDialog",0); + SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0); + SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0); + SWIG_RegisterMapping("_wxColourData","_class_wxColourData",0); + SWIG_RegisterMapping("_wxPageSetupDialogData","_class_wxPageSetupDialogData",0); + SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0); + SWIG_RegisterMapping("_class_wxQueryLayoutInfoEvent","_wxQueryLayoutInfoEvent",0); + SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0); + SWIG_RegisterMapping("_wxMDIClientWindow","_class_wxMDIClientWindow",0); + SWIG_RegisterMapping("_class_wxFontDialog","_wxFontDialog",0); + SWIG_RegisterMapping("_wxWindow","_class_wxGLCanvas",SwigwxGLCanvasTowxWindow); + SWIG_RegisterMapping("_wxWindow","_wxGLCanvas",SwigwxGLCanvasTowxWindow); + SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0); + SWIG_RegisterMapping("_class_wxFrame","_wxFrame",0); +} diff --git a/utils/wxPython/src/msw/glcanvas.py b/utils/wxPython/src/msw/glcanvas.py new file mode 100644 index 0000000000..d88c340366 --- /dev/null +++ b/utils/wxPython/src/msw/glcanvas.py @@ -0,0 +1,1423 @@ +# This file was created automatically by SWIG. +import glcanvasc + +from misc import * + +from windows import * + +from gdi import * + +from events import * + +from mdi import * + +from frames import * + +from stattool import * + +from controls import * + +from controls2 import * + +from windows2 import * + +from cmndlgs import * + +from windows3 import * +import wx +class wxGLContextPtr : + def __init__(self,this): + self.this = this + self.thisown = 0 + def __del__(self): + if self.thisown == 1 : + glcanvasc.delete_wxGLContext(self.this) + def SetCurrent(self): + val = glcanvasc.wxGLContext_SetCurrent(self.this) + return val + def SetColour(self,arg0): + val = glcanvasc.wxGLContext_SetColour(self.this,arg0) + return val + def SwapBuffers(self): + val = glcanvasc.wxGLContext_SwapBuffers(self.this) + return val + def SetupPixelFormat(self): + val = glcanvasc.wxGLContext_SetupPixelFormat(self.this) + return val + def SetupPalette(self,arg0): + val = glcanvasc.wxGLContext_SetupPalette(self.this,arg0.this) + return val + def CreateDefaultPalette(self): + val = glcanvasc.wxGLContext_CreateDefaultPalette(self.this) + val = wxPalettePtr(val) + val.thisown = 1 + return val + def GetPalette(self): + val = glcanvasc.wxGLContext_GetPalette(self.this) + val = wxPalettePtr(val) + return val + def GetWindow(self): + val = glcanvasc.wxGLContext_GetWindow(self.this) + val = wxWindowPtr(val) + return val + def __repr__(self): + return "" +class wxGLContext(wxGLContextPtr): + def __init__(self,arg0,arg1,*args) : + argl = map(None,args) + try: argl[0] = argl[0].this + except: pass + args = tuple(argl) + self.this = apply(glcanvasc.new_wxGLContext,(arg0,arg1.this,)+args) + self.thisown = 1 + + + + +class wxGLCanvasPtr(wxScrolledWindowPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def SetCurrent(self): + val = glcanvasc.wxGLCanvas_SetCurrent(self.this) + return val + def SetColour(self,arg0): + val = glcanvasc.wxGLCanvas_SetColour(self.this,arg0) + return val + def SwapBuffers(self): + val = glcanvasc.wxGLCanvas_SwapBuffers(self.this) + return val + def GetContext(self): + val = glcanvasc.wxGLCanvas_GetContext(self.this) + val = wxGLContextPtr(val) + return val + def __repr__(self): + return "" +class wxGLCanvas(wxGLCanvasPtr): + 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 + try: argl[6] = argl[6].this + except: pass + args = tuple(argl) + self.this = apply(glcanvasc.new_wxGLCanvas,(arg0.this,)+args) + self.thisown = 1 + wx._StdWindowCallbacks(self) + + + + + + +#-------------- FUNCTION WRAPPERS ------------------ + +glArrayElementEXT = glcanvasc.glArrayElementEXT + +glColorPointerEXT = glcanvasc.glColorPointerEXT + +glDrawArraysEXT = glcanvasc.glDrawArraysEXT + +glEdgeFlagPointerEXT = glcanvasc.glEdgeFlagPointerEXT + +glGetPointervEXT = glcanvasc.glGetPointervEXT + +glIndexPointerEXT = glcanvasc.glIndexPointerEXT + +glNormalPointerEXT = glcanvasc.glNormalPointerEXT + +glTexCoordPointerEXT = glcanvasc.glTexCoordPointerEXT + +glVertexPointerEXT = glcanvasc.glVertexPointerEXT + +glColorSubtableEXT = glcanvasc.glColorSubtableEXT + +glColorTableEXT = glcanvasc.glColorTableEXT + +glCopyColorTableEXT = glcanvasc.glCopyColorTableEXT + +glGetColorTableEXT = glcanvasc.glGetColorTableEXT + +glGetColorTableParamaterfvEXT = glcanvasc.glGetColorTableParamaterfvEXT + +glGetColorTavleParameterivEXT = glcanvasc.glGetColorTavleParameterivEXT + +glLockArraysSGI = glcanvasc.glLockArraysSGI + +glUnlockArraysSGI = glcanvasc.glUnlockArraysSGI + +glCullParameterdvSGI = glcanvasc.glCullParameterdvSGI + +glCullParameterfvSGI = glcanvasc.glCullParameterfvSGI + +glIndexFuncSGI = glcanvasc.glIndexFuncSGI + +glIndexMaterialSGI = glcanvasc.glIndexMaterialSGI + +glAddSwapHintRectWin = glcanvasc.glAddSwapHintRectWin + +glAccum = glcanvasc.glAccum + +glAlphaFunc = glcanvasc.glAlphaFunc + +glAreTexturesResident = glcanvasc.glAreTexturesResident + +glArrayElement = glcanvasc.glArrayElement + +glBegin = glcanvasc.glBegin + +glBindTexture = glcanvasc.glBindTexture + +glBitmap = glcanvasc.glBitmap + +glBlendFunc = glcanvasc.glBlendFunc + +glCallList = glcanvasc.glCallList + +glCallLists = glcanvasc.glCallLists + +glClear = glcanvasc.glClear + +glClearAccum = glcanvasc.glClearAccum + +glClearColor = glcanvasc.glClearColor + +glClearDepth = glcanvasc.glClearDepth + +glClearIndex = glcanvasc.glClearIndex + +glClearStencil = glcanvasc.glClearStencil + +glClipPlane = glcanvasc.glClipPlane + +glColor3b = glcanvasc.glColor3b + +glColor3bv = glcanvasc.glColor3bv + +glColor3d = glcanvasc.glColor3d + +glColor3dv = glcanvasc.glColor3dv + +glColor3f = glcanvasc.glColor3f + +glColor3fv = glcanvasc.glColor3fv + +glColor3i = glcanvasc.glColor3i + +glColor3iv = glcanvasc.glColor3iv + +glColor3s = glcanvasc.glColor3s + +glColor3sv = glcanvasc.glColor3sv + +glColor3ub = glcanvasc.glColor3ub + +glColor3ubv = glcanvasc.glColor3ubv + +glColor3ui = glcanvasc.glColor3ui + +glColor3uiv = glcanvasc.glColor3uiv + +glColor3us = glcanvasc.glColor3us + +glColor3usv = glcanvasc.glColor3usv + +glColor4b = glcanvasc.glColor4b + +glColor4bv = glcanvasc.glColor4bv + +glColor4d = glcanvasc.glColor4d + +glColor4dv = glcanvasc.glColor4dv + +glColor4f = glcanvasc.glColor4f + +glColor4fv = glcanvasc.glColor4fv + +glColor4i = glcanvasc.glColor4i + +glColor4iv = glcanvasc.glColor4iv + +glColor4s = glcanvasc.glColor4s + +glColor4sv = glcanvasc.glColor4sv + +glColor4ub = glcanvasc.glColor4ub + +glColor4ubv = glcanvasc.glColor4ubv + +glColor4ui = glcanvasc.glColor4ui + +glColor4uiv = glcanvasc.glColor4uiv + +glColor4us = glcanvasc.glColor4us + +glColor4usv = glcanvasc.glColor4usv + +glColorMask = glcanvasc.glColorMask + +glColorMaterial = glcanvasc.glColorMaterial + +glColorPointer = glcanvasc.glColorPointer + +glCopyPixels = glcanvasc.glCopyPixels + +glCopyTexImage1D = glcanvasc.glCopyTexImage1D + +glCopyTexImage2D = glcanvasc.glCopyTexImage2D + +glCopyTexSubImage1D = glcanvasc.glCopyTexSubImage1D + +glCopyTexSubImage2D = glcanvasc.glCopyTexSubImage2D + +glCullFace = glcanvasc.glCullFace + +glDeleteLists = glcanvasc.glDeleteLists + +glDeleteTextures = glcanvasc.glDeleteTextures + +glDepthFunc = glcanvasc.glDepthFunc + +glDepthMask = glcanvasc.glDepthMask + +glDepthRange = glcanvasc.glDepthRange + +glDisable = glcanvasc.glDisable + +glDisableClientState = glcanvasc.glDisableClientState + +glDrawArrays = glcanvasc.glDrawArrays + +glDrawBuffer = glcanvasc.glDrawBuffer + +glDrawElements = glcanvasc.glDrawElements + +glDrawPixels = glcanvasc.glDrawPixels + +glEdgeFlag = glcanvasc.glEdgeFlag + +glEdgeFlagPointer = glcanvasc.glEdgeFlagPointer + +glEdgeFlagv = glcanvasc.glEdgeFlagv + +glEnable = glcanvasc.glEnable + +glEnableClientState = glcanvasc.glEnableClientState + +glEnd = glcanvasc.glEnd + +glEndList = glcanvasc.glEndList + +glEvalCoord1d = glcanvasc.glEvalCoord1d + +glEvalCoord1dv = glcanvasc.glEvalCoord1dv + +glEvalCoord1f = glcanvasc.glEvalCoord1f + +glEvalCoord1fv = glcanvasc.glEvalCoord1fv + +glEvalCoord2d = glcanvasc.glEvalCoord2d + +glEvalCoord2dv = glcanvasc.glEvalCoord2dv + +glEvalCoord2f = glcanvasc.glEvalCoord2f + +glEvalCoord2fv = glcanvasc.glEvalCoord2fv + +glEvalMesh1 = glcanvasc.glEvalMesh1 + +glEvalMesh2 = glcanvasc.glEvalMesh2 + +glEvalPoint1 = glcanvasc.glEvalPoint1 + +glEvalPoint2 = glcanvasc.glEvalPoint2 + +glFeedbackBuffer = glcanvasc.glFeedbackBuffer + +glFinish = glcanvasc.glFinish + +glFlush = glcanvasc.glFlush + +glFogf = glcanvasc.glFogf + +glFogfv = glcanvasc.glFogfv + +glFogi = glcanvasc.glFogi + +glFogiv = glcanvasc.glFogiv + +glFrontFace = glcanvasc.glFrontFace + +glFrustum = glcanvasc.glFrustum + +glGenLists = glcanvasc.glGenLists + +glGenTextures = glcanvasc.glGenTextures + +glGetBooleanv = glcanvasc.glGetBooleanv + +glGetClipPlane = glcanvasc.glGetClipPlane + +glGetDoublev = glcanvasc.glGetDoublev + +glGetError = glcanvasc.glGetError + +glGetFloatv = glcanvasc.glGetFloatv + +glGetIntegerv = glcanvasc.glGetIntegerv + +glGetLightfv = glcanvasc.glGetLightfv + +glGetLightiv = glcanvasc.glGetLightiv + +glGetMapdv = glcanvasc.glGetMapdv + +glGetMapfv = glcanvasc.glGetMapfv + +glGetMapiv = glcanvasc.glGetMapiv + +glGetMaterialfv = glcanvasc.glGetMaterialfv + +glGetMaterialiv = glcanvasc.glGetMaterialiv + +glGetPixelMapfv = glcanvasc.glGetPixelMapfv + +glGetPixelMapuiv = glcanvasc.glGetPixelMapuiv + +glGetPixelMapusv = glcanvasc.glGetPixelMapusv + +glGetPointerv = glcanvasc.glGetPointerv + +glGetPolygonStipple = glcanvasc.glGetPolygonStipple + +glGetString = glcanvasc.glGetString + +glGetTexEnvfv = glcanvasc.glGetTexEnvfv + +glGetTexEnviv = glcanvasc.glGetTexEnviv + +glGetTexGendv = glcanvasc.glGetTexGendv + +glGetTexGenfv = glcanvasc.glGetTexGenfv + +glGetTexGeniv = glcanvasc.glGetTexGeniv + +glGetTexImage = glcanvasc.glGetTexImage + +glGetTexLevelParameterfv = glcanvasc.glGetTexLevelParameterfv + +glGetTexLevelParameteriv = glcanvasc.glGetTexLevelParameteriv + +glGetTexParameterfv = glcanvasc.glGetTexParameterfv + +glGetTexParameteriv = glcanvasc.glGetTexParameteriv + +glHint = glcanvasc.glHint + +glIndexMask = glcanvasc.glIndexMask + +glIndexPointer = glcanvasc.glIndexPointer + +glIndexd = glcanvasc.glIndexd + +glIndexdv = glcanvasc.glIndexdv + +glIndexf = glcanvasc.glIndexf + +glIndexfv = glcanvasc.glIndexfv + +glIndexi = glcanvasc.glIndexi + +glIndexiv = glcanvasc.glIndexiv + +glIndexs = glcanvasc.glIndexs + +glIndexsv = glcanvasc.glIndexsv + +glIndexub = glcanvasc.glIndexub + +glIndexubv = glcanvasc.glIndexubv + +glInitNames = glcanvasc.glInitNames + +glInterleavedArrays = glcanvasc.glInterleavedArrays + +glIsEnabled = glcanvasc.glIsEnabled + +glIsList = glcanvasc.glIsList + +glIsTexture = glcanvasc.glIsTexture + +glLightModelf = glcanvasc.glLightModelf + +glLightModelfv = glcanvasc.glLightModelfv + +glLightModeli = glcanvasc.glLightModeli + +glLightModeliv = glcanvasc.glLightModeliv + +glLightf = glcanvasc.glLightf + +glLightfv = glcanvasc.glLightfv + +glLighti = glcanvasc.glLighti + +glLightiv = glcanvasc.glLightiv + +glLineStipple = glcanvasc.glLineStipple + +glLineWidth = glcanvasc.glLineWidth + +glListBase = glcanvasc.glListBase + +glLoadIdentity = glcanvasc.glLoadIdentity + +glLoadMatrixd = glcanvasc.glLoadMatrixd + +glLoadMatrixf = glcanvasc.glLoadMatrixf + +glLoadName = glcanvasc.glLoadName + +glLogicOp = glcanvasc.glLogicOp + +glMap1d = glcanvasc.glMap1d + +glMap1f = glcanvasc.glMap1f + +glMap2d = glcanvasc.glMap2d + +glMap2f = glcanvasc.glMap2f + +glMapGrid1d = glcanvasc.glMapGrid1d + +glMapGrid1f = glcanvasc.glMapGrid1f + +glMapGrid2d = glcanvasc.glMapGrid2d + +glMapGrid2f = glcanvasc.glMapGrid2f + +glMaterialf = glcanvasc.glMaterialf + +glMaterialfv = glcanvasc.glMaterialfv + +glMateriali = glcanvasc.glMateriali + +glMaterialiv = glcanvasc.glMaterialiv + +glMatrixMode = glcanvasc.glMatrixMode + +glMultMatrixd = glcanvasc.glMultMatrixd + +glMultMatrixf = glcanvasc.glMultMatrixf + +glNewList = glcanvasc.glNewList + +glNormal3b = glcanvasc.glNormal3b + +glNormal3bv = glcanvasc.glNormal3bv + +glNormal3d = glcanvasc.glNormal3d + +glNormal3dv = glcanvasc.glNormal3dv + +glNormal3f = glcanvasc.glNormal3f + +glNormal3fv = glcanvasc.glNormal3fv + +glNormal3i = glcanvasc.glNormal3i + +glNormal3iv = glcanvasc.glNormal3iv + +glNormal3s = glcanvasc.glNormal3s + +glNormal3sv = glcanvasc.glNormal3sv + +glNormalPointer = glcanvasc.glNormalPointer + +glOrtho = glcanvasc.glOrtho + +glPassThrough = glcanvasc.glPassThrough + +glPixelMapfv = glcanvasc.glPixelMapfv + +glPixelMapuiv = glcanvasc.glPixelMapuiv + +glPixelMapusv = glcanvasc.glPixelMapusv + +glPixelStoref = glcanvasc.glPixelStoref + +glPixelStorei = glcanvasc.glPixelStorei + +glPixelTransferf = glcanvasc.glPixelTransferf + +glPixelTransferi = glcanvasc.glPixelTransferi + +glPixelZoom = glcanvasc.glPixelZoom + +glPointSize = glcanvasc.glPointSize + +glPolygonMode = glcanvasc.glPolygonMode + +glPolygonOffset = glcanvasc.glPolygonOffset + +glPolygonStipple = glcanvasc.glPolygonStipple + +glPopAttrib = glcanvasc.glPopAttrib + +glPopClientAttrib = glcanvasc.glPopClientAttrib + +glPopMatrix = glcanvasc.glPopMatrix + +glPopName = glcanvasc.glPopName + +glPrioritizeTextures = glcanvasc.glPrioritizeTextures + +glPushAttrib = glcanvasc.glPushAttrib + +glPushClientAttrib = glcanvasc.glPushClientAttrib + +glPushMatrix = glcanvasc.glPushMatrix + +glPushName = glcanvasc.glPushName + +glRasterPos2d = glcanvasc.glRasterPos2d + +glRasterPos2dv = glcanvasc.glRasterPos2dv + +glRasterPos2f = glcanvasc.glRasterPos2f + +glRasterPos2fv = glcanvasc.glRasterPos2fv + +glRasterPos2i = glcanvasc.glRasterPos2i + +glRasterPos2iv = glcanvasc.glRasterPos2iv + +glRasterPos2s = glcanvasc.glRasterPos2s + +glRasterPos2sv = glcanvasc.glRasterPos2sv + +glRasterPos3d = glcanvasc.glRasterPos3d + +glRasterPos3dv = glcanvasc.glRasterPos3dv + +glRasterPos3f = glcanvasc.glRasterPos3f + +glRasterPos3fv = glcanvasc.glRasterPos3fv + +glRasterPos3i = glcanvasc.glRasterPos3i + +glRasterPos3iv = glcanvasc.glRasterPos3iv + +glRasterPos3s = glcanvasc.glRasterPos3s + +glRasterPos3sv = glcanvasc.glRasterPos3sv + +glRasterPos4d = glcanvasc.glRasterPos4d + +glRasterPos4dv = glcanvasc.glRasterPos4dv + +glRasterPos4f = glcanvasc.glRasterPos4f + +glRasterPos4fv = glcanvasc.glRasterPos4fv + +glRasterPos4i = glcanvasc.glRasterPos4i + +glRasterPos4iv = glcanvasc.glRasterPos4iv + +glRasterPos4s = glcanvasc.glRasterPos4s + +glRasterPos4sv = glcanvasc.glRasterPos4sv + +glReadBuffer = glcanvasc.glReadBuffer + +glReadPixels = glcanvasc.glReadPixels + +glRectd = glcanvasc.glRectd + +glRectdv = glcanvasc.glRectdv + +glRectf = glcanvasc.glRectf + +glRectfv = glcanvasc.glRectfv + +glRecti = glcanvasc.glRecti + +glRectiv = glcanvasc.glRectiv + +glRects = glcanvasc.glRects + +glRectsv = glcanvasc.glRectsv + +glRenderMode = glcanvasc.glRenderMode + +glRotated = glcanvasc.glRotated + +glRotatef = glcanvasc.glRotatef + +glScaled = glcanvasc.glScaled + +glScalef = glcanvasc.glScalef + +glScissor = glcanvasc.glScissor + +glSelectBuffer = glcanvasc.glSelectBuffer + +glShadeModel = glcanvasc.glShadeModel + +glStencilFunc = glcanvasc.glStencilFunc + +glStencilMask = glcanvasc.glStencilMask + +glStencilOp = glcanvasc.glStencilOp + +glTexCoord1d = glcanvasc.glTexCoord1d + +glTexCoord1dv = glcanvasc.glTexCoord1dv + +glTexCoord1f = glcanvasc.glTexCoord1f + +glTexCoord1fv = glcanvasc.glTexCoord1fv + +glTexCoord1i = glcanvasc.glTexCoord1i + +glTexCoord1iv = glcanvasc.glTexCoord1iv + +glTexCoord1s = glcanvasc.glTexCoord1s + +glTexCoord1sv = glcanvasc.glTexCoord1sv + +glTexCoord2d = glcanvasc.glTexCoord2d + +glTexCoord2dv = glcanvasc.glTexCoord2dv + +glTexCoord2f = glcanvasc.glTexCoord2f + +glTexCoord2fv = glcanvasc.glTexCoord2fv + +glTexCoord2i = glcanvasc.glTexCoord2i + +glTexCoord2iv = glcanvasc.glTexCoord2iv + +glTexCoord2s = glcanvasc.glTexCoord2s + +glTexCoord2sv = glcanvasc.glTexCoord2sv + +glTexCoord3d = glcanvasc.glTexCoord3d + +glTexCoord3dv = glcanvasc.glTexCoord3dv + +glTexCoord3f = glcanvasc.glTexCoord3f + +glTexCoord3fv = glcanvasc.glTexCoord3fv + +glTexCoord3i = glcanvasc.glTexCoord3i + +glTexCoord3iv = glcanvasc.glTexCoord3iv + +glTexCoord3s = glcanvasc.glTexCoord3s + +glTexCoord3sv = glcanvasc.glTexCoord3sv + +glTexCoord4d = glcanvasc.glTexCoord4d + +glTexCoord4dv = glcanvasc.glTexCoord4dv + +glTexCoord4f = glcanvasc.glTexCoord4f + +glTexCoord4fv = glcanvasc.glTexCoord4fv + +glTexCoord4i = glcanvasc.glTexCoord4i + +glTexCoord4iv = glcanvasc.glTexCoord4iv + +glTexCoord4s = glcanvasc.glTexCoord4s + +glTexCoord4sv = glcanvasc.glTexCoord4sv + +glTexCoordPointer = glcanvasc.glTexCoordPointer + +glTexEnvf = glcanvasc.glTexEnvf + +glTexEnvfv = glcanvasc.glTexEnvfv + +glTexEnvi = glcanvasc.glTexEnvi + +glTexEnviv = glcanvasc.glTexEnviv + +glTexGend = glcanvasc.glTexGend + +glTexGendv = glcanvasc.glTexGendv + +glTexGenf = glcanvasc.glTexGenf + +glTexGenfv = glcanvasc.glTexGenfv + +glTexGeni = glcanvasc.glTexGeni + +glTexGeniv = glcanvasc.glTexGeniv + +glTexImage1D = glcanvasc.glTexImage1D + +glTexImage2D = glcanvasc.glTexImage2D + +glTexParameterf = glcanvasc.glTexParameterf + +glTexParameterfv = glcanvasc.glTexParameterfv + +glTexParameteri = glcanvasc.glTexParameteri + +glTexParameteriv = glcanvasc.glTexParameteriv + +glTexSubImage1D = glcanvasc.glTexSubImage1D + +glTexSubImage2D = glcanvasc.glTexSubImage2D + +glTranslated = glcanvasc.glTranslated + +glTranslatef = glcanvasc.glTranslatef + +glVertex2d = glcanvasc.glVertex2d + +glVertex2dv = glcanvasc.glVertex2dv + +glVertex2f = glcanvasc.glVertex2f + +glVertex2fv = glcanvasc.glVertex2fv + +glVertex2i = glcanvasc.glVertex2i + +glVertex2iv = glcanvasc.glVertex2iv + +glVertex2s = glcanvasc.glVertex2s + +glVertex2sv = glcanvasc.glVertex2sv + +glVertex3d = glcanvasc.glVertex3d + +glVertex3dv = glcanvasc.glVertex3dv + +glVertex3f = glcanvasc.glVertex3f + +glVertex3fv = glcanvasc.glVertex3fv + +glVertex3i = glcanvasc.glVertex3i + +glVertex3iv = glcanvasc.glVertex3iv + +glVertex3s = glcanvasc.glVertex3s + +glVertex3sv = glcanvasc.glVertex3sv + +glVertex4d = glcanvasc.glVertex4d + +glVertex4dv = glcanvasc.glVertex4dv + +glVertex4f = glcanvasc.glVertex4f + +glVertex4fv = glcanvasc.glVertex4fv + +glVertex4i = glcanvasc.glVertex4i + +glVertex4iv = glcanvasc.glVertex4iv + +glVertex4s = glcanvasc.glVertex4s + +glVertex4sv = glcanvasc.glVertex4sv + +glVertexPointer = glcanvasc.glVertexPointer + +glViewport = glcanvasc.glViewport + + + +#-------------- VARIABLE WRAPPERS ------------------ + +GL_2D = glcanvasc.GL_2D +GL_2_BYTES = glcanvasc.GL_2_BYTES +GL_3D = glcanvasc.GL_3D +GL_3D_COLOR = glcanvasc.GL_3D_COLOR +GL_3D_COLOR_TEXTURE = glcanvasc.GL_3D_COLOR_TEXTURE +GL_3_BYTES = glcanvasc.GL_3_BYTES +GL_4D_COLOR_TEXTURE = glcanvasc.GL_4D_COLOR_TEXTURE +GL_4_BYTES = glcanvasc.GL_4_BYTES +GL_ACCUM = glcanvasc.GL_ACCUM +GL_ACCUM_ALPHA_BITS = glcanvasc.GL_ACCUM_ALPHA_BITS +GL_ACCUM_BLUE_BITS = glcanvasc.GL_ACCUM_BLUE_BITS +GL_ACCUM_BUFFER_BIT = glcanvasc.GL_ACCUM_BUFFER_BIT +GL_ACCUM_CLEAR_VALUE = glcanvasc.GL_ACCUM_CLEAR_VALUE +GL_ACCUM_GREEN_BITS = glcanvasc.GL_ACCUM_GREEN_BITS +GL_ACCUM_RED_BITS = glcanvasc.GL_ACCUM_RED_BITS +GL_ADD = glcanvasc.GL_ADD +GL_ALL_ATTRIB_BITS = glcanvasc.GL_ALL_ATTRIB_BITS +GL_ALPHA = glcanvasc.GL_ALPHA +GL_ALPHA12 = glcanvasc.GL_ALPHA12 +GL_ALPHA16 = glcanvasc.GL_ALPHA16 +GL_ALPHA4 = glcanvasc.GL_ALPHA4 +GL_ALPHA8 = glcanvasc.GL_ALPHA8 +GL_ALPHA_BIAS = glcanvasc.GL_ALPHA_BIAS +GL_ALPHA_BITS = glcanvasc.GL_ALPHA_BITS +GL_ALPHA_SCALE = glcanvasc.GL_ALPHA_SCALE +GL_ALPHA_TEST = glcanvasc.GL_ALPHA_TEST +GL_ALPHA_TEST_FUNC = glcanvasc.GL_ALPHA_TEST_FUNC +GL_ALPHA_TEST_REF = glcanvasc.GL_ALPHA_TEST_REF +GL_ALWAYS = glcanvasc.GL_ALWAYS +GL_AMBIENT = glcanvasc.GL_AMBIENT +GL_AMBIENT_AND_DIFFUSE = glcanvasc.GL_AMBIENT_AND_DIFFUSE +GL_AND = glcanvasc.GL_AND +GL_AND_INVERTED = glcanvasc.GL_AND_INVERTED +GL_AND_REVERSE = glcanvasc.GL_AND_REVERSE +GL_ATTRIB_STACK_DEPTH = glcanvasc.GL_ATTRIB_STACK_DEPTH +GL_AUTO_NORMAL = glcanvasc.GL_AUTO_NORMAL +GL_AUX0 = glcanvasc.GL_AUX0 +GL_AUX1 = glcanvasc.GL_AUX1 +GL_AUX2 = glcanvasc.GL_AUX2 +GL_AUX3 = glcanvasc.GL_AUX3 +GL_AUX_BUFFERS = glcanvasc.GL_AUX_BUFFERS +GL_BACK = glcanvasc.GL_BACK +GL_BACK_LEFT = glcanvasc.GL_BACK_LEFT +GL_BACK_RIGHT = glcanvasc.GL_BACK_RIGHT +GL_BGRA_EXT = glcanvasc.GL_BGRA_EXT +GL_BGR_EXT = glcanvasc.GL_BGR_EXT +GL_BITMAP = glcanvasc.GL_BITMAP +GL_BITMAP_TOKEN = glcanvasc.GL_BITMAP_TOKEN +GL_BLEND = glcanvasc.GL_BLEND +GL_BLEND_DST = glcanvasc.GL_BLEND_DST +GL_BLEND_SRC = glcanvasc.GL_BLEND_SRC +GL_BLUE = glcanvasc.GL_BLUE +GL_BLUE_BIAS = glcanvasc.GL_BLUE_BIAS +GL_BLUE_BITS = glcanvasc.GL_BLUE_BITS +GL_BLUE_SCALE = glcanvasc.GL_BLUE_SCALE +GL_BYTE = glcanvasc.GL_BYTE +GL_C3F_V3F = glcanvasc.GL_C3F_V3F +GL_C4F_N3F_V3F = glcanvasc.GL_C4F_N3F_V3F +GL_C4UB_V2F = glcanvasc.GL_C4UB_V2F +GL_C4UB_V3F = glcanvasc.GL_C4UB_V3F +GL_CCW = glcanvasc.GL_CCW +GL_CLAMP = glcanvasc.GL_CLAMP +GL_CLEAR = glcanvasc.GL_CLEAR +GL_CLIENT_ALL_ATTRIB_BITS = glcanvasc.GL_CLIENT_ALL_ATTRIB_BITS +GL_CLIENT_ATTRIB_STACK_DEPTH = glcanvasc.GL_CLIENT_ATTRIB_STACK_DEPTH +GL_CLIENT_PIXEL_STORE_BIT = glcanvasc.GL_CLIENT_PIXEL_STORE_BIT +GL_CLIENT_VERTEX_ARRAY_BIT = glcanvasc.GL_CLIENT_VERTEX_ARRAY_BIT +GL_CLIP_PLANE0 = glcanvasc.GL_CLIP_PLANE0 +GL_CLIP_PLANE1 = glcanvasc.GL_CLIP_PLANE1 +GL_CLIP_PLANE2 = glcanvasc.GL_CLIP_PLANE2 +GL_CLIP_PLANE3 = glcanvasc.GL_CLIP_PLANE3 +GL_CLIP_PLANE4 = glcanvasc.GL_CLIP_PLANE4 +GL_CLIP_PLANE5 = glcanvasc.GL_CLIP_PLANE5 +GL_COEFF = glcanvasc.GL_COEFF +GL_COLOR = glcanvasc.GL_COLOR +GL_COLOR_ARRAY = glcanvasc.GL_COLOR_ARRAY +GL_COLOR_ARRAY_COUNT_EXT = glcanvasc.GL_COLOR_ARRAY_COUNT_EXT +GL_COLOR_ARRAY_EXT = glcanvasc.GL_COLOR_ARRAY_EXT +GL_COLOR_ARRAY_POINTER = glcanvasc.GL_COLOR_ARRAY_POINTER +GL_COLOR_ARRAY_POINTER_EXT = glcanvasc.GL_COLOR_ARRAY_POINTER_EXT +GL_COLOR_ARRAY_SIZE = glcanvasc.GL_COLOR_ARRAY_SIZE +GL_COLOR_ARRAY_SIZE_EXT = glcanvasc.GL_COLOR_ARRAY_SIZE_EXT +GL_COLOR_ARRAY_STRIDE = glcanvasc.GL_COLOR_ARRAY_STRIDE +GL_COLOR_ARRAY_STRIDE_EXT = glcanvasc.GL_COLOR_ARRAY_STRIDE_EXT +GL_COLOR_ARRAY_TYPE = glcanvasc.GL_COLOR_ARRAY_TYPE +GL_COLOR_ARRAY_TYPE_EXT = glcanvasc.GL_COLOR_ARRAY_TYPE_EXT +GL_COLOR_BUFFER_BIT = glcanvasc.GL_COLOR_BUFFER_BIT +GL_COLOR_CLEAR_VALUE = glcanvasc.GL_COLOR_CLEAR_VALUE +GL_COLOR_INDEX = glcanvasc.GL_COLOR_INDEX +GL_COLOR_INDEX12_EXT = glcanvasc.GL_COLOR_INDEX12_EXT +GL_COLOR_INDEX16_EXT = glcanvasc.GL_COLOR_INDEX16_EXT +GL_COLOR_INDEX1_EXT = glcanvasc.GL_COLOR_INDEX1_EXT +GL_COLOR_INDEX2_EXT = glcanvasc.GL_COLOR_INDEX2_EXT +GL_COLOR_INDEX4_EXT = glcanvasc.GL_COLOR_INDEX4_EXT +GL_COLOR_INDEX8_EXT = glcanvasc.GL_COLOR_INDEX8_EXT +GL_COLOR_INDEXES = glcanvasc.GL_COLOR_INDEXES +GL_COLOR_LOGIC_OP = glcanvasc.GL_COLOR_LOGIC_OP +GL_COLOR_MATERIAL = glcanvasc.GL_COLOR_MATERIAL +GL_COLOR_MATERIAL_FACE = glcanvasc.GL_COLOR_MATERIAL_FACE +GL_COLOR_MATERIAL_PARAMETER = glcanvasc.GL_COLOR_MATERIAL_PARAMETER +GL_COLOR_TABLE_ALPHA_SIZE_EXT = glcanvasc.GL_COLOR_TABLE_ALPHA_SIZE_EXT +GL_COLOR_TABLE_BLUE_SIZE_EXT = glcanvasc.GL_COLOR_TABLE_BLUE_SIZE_EXT +GL_COLOR_TABLE_FORMAT_EXT = glcanvasc.GL_COLOR_TABLE_FORMAT_EXT +GL_COLOR_TABLE_GREEN_SIZE_EXT = glcanvasc.GL_COLOR_TABLE_GREEN_SIZE_EXT +GL_COLOR_TABLE_INTENSITY_SIZE_EXT = glcanvasc.GL_COLOR_TABLE_INTENSITY_SIZE_EXT +GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = glcanvasc.GL_COLOR_TABLE_LUMINANCE_SIZE_EXT +GL_COLOR_TABLE_RED_SIZE_EXT = glcanvasc.GL_COLOR_TABLE_RED_SIZE_EXT +GL_COLOR_TABLE_WIDTH_EXT = glcanvasc.GL_COLOR_TABLE_WIDTH_EXT +GL_COLOR_WRITEMASK = glcanvasc.GL_COLOR_WRITEMASK +GL_COMPILE = glcanvasc.GL_COMPILE +GL_COMPILE_AND_EXECUTE = glcanvasc.GL_COMPILE_AND_EXECUTE +GL_CONSTANT_ATTENUATION = glcanvasc.GL_CONSTANT_ATTENUATION +GL_COPY = glcanvasc.GL_COPY +GL_COPY_INVERTED = glcanvasc.GL_COPY_INVERTED +GL_COPY_PIXEL_TOKEN = glcanvasc.GL_COPY_PIXEL_TOKEN +GL_CULL_FACE = glcanvasc.GL_CULL_FACE +GL_CULL_FACE_MODE = glcanvasc.GL_CULL_FACE_MODE +GL_CURRENT_BIT = glcanvasc.GL_CURRENT_BIT +GL_CURRENT_COLOR = glcanvasc.GL_CURRENT_COLOR +GL_CURRENT_INDEX = glcanvasc.GL_CURRENT_INDEX +GL_CURRENT_NORMAL = glcanvasc.GL_CURRENT_NORMAL +GL_CURRENT_RASTER_COLOR = glcanvasc.GL_CURRENT_RASTER_COLOR +GL_CURRENT_RASTER_DISTANCE = glcanvasc.GL_CURRENT_RASTER_DISTANCE +GL_CURRENT_RASTER_INDEX = glcanvasc.GL_CURRENT_RASTER_INDEX +GL_CURRENT_RASTER_POSITION = glcanvasc.GL_CURRENT_RASTER_POSITION +GL_CURRENT_RASTER_POSITION_VALID = glcanvasc.GL_CURRENT_RASTER_POSITION_VALID +GL_CURRENT_RASTER_TEXTURE_COORDS = glcanvasc.GL_CURRENT_RASTER_TEXTURE_COORDS +GL_CURRENT_TEXTURE_COORDS = glcanvasc.GL_CURRENT_TEXTURE_COORDS +GL_CW = glcanvasc.GL_CW +GL_DECAL = glcanvasc.GL_DECAL +GL_DECR = glcanvasc.GL_DECR +GL_DEPTH = glcanvasc.GL_DEPTH +GL_DEPTH_BIAS = glcanvasc.GL_DEPTH_BIAS +GL_DEPTH_BITS = glcanvasc.GL_DEPTH_BITS +GL_DEPTH_BUFFER_BIT = glcanvasc.GL_DEPTH_BUFFER_BIT +GL_DEPTH_CLEAR_VALUE = glcanvasc.GL_DEPTH_CLEAR_VALUE +GL_DEPTH_COMPONENT = glcanvasc.GL_DEPTH_COMPONENT +GL_DEPTH_FUNC = glcanvasc.GL_DEPTH_FUNC +GL_DEPTH_RANGE = glcanvasc.GL_DEPTH_RANGE +GL_DEPTH_SCALE = glcanvasc.GL_DEPTH_SCALE +GL_DEPTH_TEST = glcanvasc.GL_DEPTH_TEST +GL_DEPTH_WRITEMASK = glcanvasc.GL_DEPTH_WRITEMASK +GL_DIFFUSE = glcanvasc.GL_DIFFUSE +GL_DITHER = glcanvasc.GL_DITHER +GL_DOMAIN = glcanvasc.GL_DOMAIN +GL_DONT_CARE = glcanvasc.GL_DONT_CARE +GL_DOUBLE = glcanvasc.GL_DOUBLE +GL_DOUBLEBUFFER = glcanvasc.GL_DOUBLEBUFFER +GL_DOUBLE_EXT = glcanvasc.GL_DOUBLE_EXT +GL_DRAW_BUFFER = glcanvasc.GL_DRAW_BUFFER +GL_DRAW_PIXEL_TOKEN = glcanvasc.GL_DRAW_PIXEL_TOKEN +GL_DST_ALPHA = glcanvasc.GL_DST_ALPHA +GL_DST_COLOR = glcanvasc.GL_DST_COLOR +GL_EDGE_FLAG = glcanvasc.GL_EDGE_FLAG +GL_EDGE_FLAG_ARRAY = glcanvasc.GL_EDGE_FLAG_ARRAY +GL_EDGE_FLAG_ARRAY_COUNT_EXT = glcanvasc.GL_EDGE_FLAG_ARRAY_COUNT_EXT +GL_EDGE_FLAG_ARRAY_EXT = glcanvasc.GL_EDGE_FLAG_ARRAY_EXT +GL_EDGE_FLAG_ARRAY_POINTER = glcanvasc.GL_EDGE_FLAG_ARRAY_POINTER +GL_EDGE_FLAG_ARRAY_POINTER_EXT = glcanvasc.GL_EDGE_FLAG_ARRAY_POINTER_EXT +GL_EDGE_FLAG_ARRAY_STRIDE = glcanvasc.GL_EDGE_FLAG_ARRAY_STRIDE +GL_EDGE_FLAG_ARRAY_STRIDE_EXT = glcanvasc.GL_EDGE_FLAG_ARRAY_STRIDE_EXT +GL_EMISSION = glcanvasc.GL_EMISSION +GL_ENABLE_BIT = glcanvasc.GL_ENABLE_BIT +GL_EQUAL = glcanvasc.GL_EQUAL +GL_EQUIV = glcanvasc.GL_EQUIV +GL_EVAL_BIT = glcanvasc.GL_EVAL_BIT +GL_EXP = glcanvasc.GL_EXP +GL_EXP2 = glcanvasc.GL_EXP2 +GL_EXTENSIONS = glcanvasc.GL_EXTENSIONS +GL_EXT_bgra = glcanvasc.GL_EXT_bgra +GL_EXT_paletted_texture = glcanvasc.GL_EXT_paletted_texture +GL_EXT_vertex_array = glcanvasc.GL_EXT_vertex_array +GL_EYE_LINEAR = glcanvasc.GL_EYE_LINEAR +GL_EYE_PLANE = glcanvasc.GL_EYE_PLANE +GL_FALSE = glcanvasc.GL_FALSE +GL_FASTEST = glcanvasc.GL_FASTEST +GL_FEEDBACK = glcanvasc.GL_FEEDBACK +GL_FEEDBACK_BUFFER_POINTER = glcanvasc.GL_FEEDBACK_BUFFER_POINTER +GL_FEEDBACK_BUFFER_SIZE = glcanvasc.GL_FEEDBACK_BUFFER_SIZE +GL_FEEDBACK_BUFFER_TYPE = glcanvasc.GL_FEEDBACK_BUFFER_TYPE +GL_FILL = glcanvasc.GL_FILL +GL_FLAT = glcanvasc.GL_FLAT +GL_FLOAT = glcanvasc.GL_FLOAT +GL_FOG = glcanvasc.GL_FOG +GL_FOG_BIT = glcanvasc.GL_FOG_BIT +GL_FOG_COLOR = glcanvasc.GL_FOG_COLOR +GL_FOG_DENSITY = glcanvasc.GL_FOG_DENSITY +GL_FOG_END = glcanvasc.GL_FOG_END +GL_FOG_HINT = glcanvasc.GL_FOG_HINT +GL_FOG_INDEX = glcanvasc.GL_FOG_INDEX +GL_FOG_MODE = glcanvasc.GL_FOG_MODE +GL_FOG_SPECULAR_TEXTURE_WIN = glcanvasc.GL_FOG_SPECULAR_TEXTURE_WIN +GL_FOG_START = glcanvasc.GL_FOG_START +GL_FRONT = glcanvasc.GL_FRONT +GL_FRONT_AND_BACK = glcanvasc.GL_FRONT_AND_BACK +GL_FRONT_FACE = glcanvasc.GL_FRONT_FACE +GL_FRONT_LEFT = glcanvasc.GL_FRONT_LEFT +GL_FRONT_RIGHT = glcanvasc.GL_FRONT_RIGHT +GL_GEQUAL = glcanvasc.GL_GEQUAL +GL_GREATER = glcanvasc.GL_GREATER +GL_GREEN = glcanvasc.GL_GREEN +GL_GREEN_BIAS = glcanvasc.GL_GREEN_BIAS +GL_GREEN_BITS = glcanvasc.GL_GREEN_BITS +GL_GREEN_SCALE = glcanvasc.GL_GREEN_SCALE +GL_HINT_BIT = glcanvasc.GL_HINT_BIT +GL_INCR = glcanvasc.GL_INCR +GL_INDEX_ARRAY = glcanvasc.GL_INDEX_ARRAY +GL_INDEX_ARRAY_COUNT_EXT = glcanvasc.GL_INDEX_ARRAY_COUNT_EXT +GL_INDEX_ARRAY_EXT = glcanvasc.GL_INDEX_ARRAY_EXT +GL_INDEX_ARRAY_POINTER = glcanvasc.GL_INDEX_ARRAY_POINTER +GL_INDEX_ARRAY_POINTER_EXT = glcanvasc.GL_INDEX_ARRAY_POINTER_EXT +GL_INDEX_ARRAY_STRIDE = glcanvasc.GL_INDEX_ARRAY_STRIDE +GL_INDEX_ARRAY_STRIDE_EXT = glcanvasc.GL_INDEX_ARRAY_STRIDE_EXT +GL_INDEX_ARRAY_TYPE = glcanvasc.GL_INDEX_ARRAY_TYPE +GL_INDEX_ARRAY_TYPE_EXT = glcanvasc.GL_INDEX_ARRAY_TYPE_EXT +GL_INDEX_BITS = glcanvasc.GL_INDEX_BITS +GL_INDEX_CLEAR_VALUE = glcanvasc.GL_INDEX_CLEAR_VALUE +GL_INDEX_LOGIC_OP = glcanvasc.GL_INDEX_LOGIC_OP +GL_INDEX_MODE = glcanvasc.GL_INDEX_MODE +GL_INDEX_OFFSET = glcanvasc.GL_INDEX_OFFSET +GL_INDEX_SHIFT = glcanvasc.GL_INDEX_SHIFT +GL_INDEX_WRITEMASK = glcanvasc.GL_INDEX_WRITEMASK +GL_INT = glcanvasc.GL_INT +GL_INTENSITY = glcanvasc.GL_INTENSITY +GL_INTENSITY12 = glcanvasc.GL_INTENSITY12 +GL_INTENSITY16 = glcanvasc.GL_INTENSITY16 +GL_INTENSITY4 = glcanvasc.GL_INTENSITY4 +GL_INTENSITY8 = glcanvasc.GL_INTENSITY8 +GL_INVALID_ENUM = glcanvasc.GL_INVALID_ENUM +GL_INVALID_OPERATION = glcanvasc.GL_INVALID_OPERATION +GL_INVALID_VALUE = glcanvasc.GL_INVALID_VALUE +GL_INVERT = glcanvasc.GL_INVERT +GL_KEEP = glcanvasc.GL_KEEP +GL_LEFT = glcanvasc.GL_LEFT +GL_LEQUAL = glcanvasc.GL_LEQUAL +GL_LESS = glcanvasc.GL_LESS +GL_LIGHT0 = glcanvasc.GL_LIGHT0 +GL_LIGHT1 = glcanvasc.GL_LIGHT1 +GL_LIGHT2 = glcanvasc.GL_LIGHT2 +GL_LIGHT3 = glcanvasc.GL_LIGHT3 +GL_LIGHT4 = glcanvasc.GL_LIGHT4 +GL_LIGHT5 = glcanvasc.GL_LIGHT5 +GL_LIGHT6 = glcanvasc.GL_LIGHT6 +GL_LIGHT7 = glcanvasc.GL_LIGHT7 +GL_LIGHTING = glcanvasc.GL_LIGHTING +GL_LIGHTING_BIT = glcanvasc.GL_LIGHTING_BIT +GL_LIGHT_MODEL_AMBIENT = glcanvasc.GL_LIGHT_MODEL_AMBIENT +GL_LIGHT_MODEL_LOCAL_VIEWER = glcanvasc.GL_LIGHT_MODEL_LOCAL_VIEWER +GL_LIGHT_MODEL_TWO_SIDE = glcanvasc.GL_LIGHT_MODEL_TWO_SIDE +GL_LINE = glcanvasc.GL_LINE +GL_LINEAR = glcanvasc.GL_LINEAR +GL_LINEAR_ATTENUATION = glcanvasc.GL_LINEAR_ATTENUATION +GL_LINEAR_MIPMAP_LINEAR = glcanvasc.GL_LINEAR_MIPMAP_LINEAR +GL_LINEAR_MIPMAP_NEAREST = glcanvasc.GL_LINEAR_MIPMAP_NEAREST +GL_LINES = glcanvasc.GL_LINES +GL_LINE_BIT = glcanvasc.GL_LINE_BIT +GL_LINE_LOOP = glcanvasc.GL_LINE_LOOP +GL_LINE_RESET_TOKEN = glcanvasc.GL_LINE_RESET_TOKEN +GL_LINE_SMOOTH = glcanvasc.GL_LINE_SMOOTH +GL_LINE_SMOOTH_HINT = glcanvasc.GL_LINE_SMOOTH_HINT +GL_LINE_STIPPLE = glcanvasc.GL_LINE_STIPPLE +GL_LINE_STIPPLE_PATTERN = glcanvasc.GL_LINE_STIPPLE_PATTERN +GL_LINE_STIPPLE_REPEAT = glcanvasc.GL_LINE_STIPPLE_REPEAT +GL_LINE_STRIP = glcanvasc.GL_LINE_STRIP +GL_LINE_TOKEN = glcanvasc.GL_LINE_TOKEN +GL_LINE_WIDTH = glcanvasc.GL_LINE_WIDTH +GL_LINE_WIDTH_GRANULARITY = glcanvasc.GL_LINE_WIDTH_GRANULARITY +GL_LINE_WIDTH_RANGE = glcanvasc.GL_LINE_WIDTH_RANGE +GL_LIST_BASE = glcanvasc.GL_LIST_BASE +GL_LIST_BIT = glcanvasc.GL_LIST_BIT +GL_LIST_INDEX = glcanvasc.GL_LIST_INDEX +GL_LIST_MODE = glcanvasc.GL_LIST_MODE +GL_LOAD = glcanvasc.GL_LOAD +GL_LOGIC_OP = glcanvasc.GL_LOGIC_OP +GL_LOGIC_OP_MODE = glcanvasc.GL_LOGIC_OP_MODE +GL_LUMINANCE = glcanvasc.GL_LUMINANCE +GL_LUMINANCE12 = glcanvasc.GL_LUMINANCE12 +GL_LUMINANCE12_ALPHA12 = glcanvasc.GL_LUMINANCE12_ALPHA12 +GL_LUMINANCE12_ALPHA4 = glcanvasc.GL_LUMINANCE12_ALPHA4 +GL_LUMINANCE16 = glcanvasc.GL_LUMINANCE16 +GL_LUMINANCE16_ALPHA16 = glcanvasc.GL_LUMINANCE16_ALPHA16 +GL_LUMINANCE4 = glcanvasc.GL_LUMINANCE4 +GL_LUMINANCE4_ALPHA4 = glcanvasc.GL_LUMINANCE4_ALPHA4 +GL_LUMINANCE6_ALPHA2 = glcanvasc.GL_LUMINANCE6_ALPHA2 +GL_LUMINANCE8 = glcanvasc.GL_LUMINANCE8 +GL_LUMINANCE8_ALPHA8 = glcanvasc.GL_LUMINANCE8_ALPHA8 +GL_LUMINANCE_ALPHA = glcanvasc.GL_LUMINANCE_ALPHA +GL_MAP1_COLOR_4 = glcanvasc.GL_MAP1_COLOR_4 +GL_MAP1_GRID_DOMAIN = glcanvasc.GL_MAP1_GRID_DOMAIN +GL_MAP1_GRID_SEGMENTS = glcanvasc.GL_MAP1_GRID_SEGMENTS +GL_MAP1_INDEX = glcanvasc.GL_MAP1_INDEX +GL_MAP1_NORMAL = glcanvasc.GL_MAP1_NORMAL +GL_MAP1_TEXTURE_COORD_1 = glcanvasc.GL_MAP1_TEXTURE_COORD_1 +GL_MAP1_TEXTURE_COORD_2 = glcanvasc.GL_MAP1_TEXTURE_COORD_2 +GL_MAP1_TEXTURE_COORD_3 = glcanvasc.GL_MAP1_TEXTURE_COORD_3 +GL_MAP1_TEXTURE_COORD_4 = glcanvasc.GL_MAP1_TEXTURE_COORD_4 +GL_MAP1_VERTEX_3 = glcanvasc.GL_MAP1_VERTEX_3 +GL_MAP1_VERTEX_4 = glcanvasc.GL_MAP1_VERTEX_4 +GL_MAP2_COLOR_4 = glcanvasc.GL_MAP2_COLOR_4 +GL_MAP2_GRID_DOMAIN = glcanvasc.GL_MAP2_GRID_DOMAIN +GL_MAP2_GRID_SEGMENTS = glcanvasc.GL_MAP2_GRID_SEGMENTS +GL_MAP2_INDEX = glcanvasc.GL_MAP2_INDEX +GL_MAP2_NORMAL = glcanvasc.GL_MAP2_NORMAL +GL_MAP2_TEXTURE_COORD_1 = glcanvasc.GL_MAP2_TEXTURE_COORD_1 +GL_MAP2_TEXTURE_COORD_2 = glcanvasc.GL_MAP2_TEXTURE_COORD_2 +GL_MAP2_TEXTURE_COORD_3 = glcanvasc.GL_MAP2_TEXTURE_COORD_3 +GL_MAP2_TEXTURE_COORD_4 = glcanvasc.GL_MAP2_TEXTURE_COORD_4 +GL_MAP2_VERTEX_3 = glcanvasc.GL_MAP2_VERTEX_3 +GL_MAP2_VERTEX_4 = glcanvasc.GL_MAP2_VERTEX_4 +GL_MAP_COLOR = glcanvasc.GL_MAP_COLOR +GL_MAP_STENCIL = glcanvasc.GL_MAP_STENCIL +GL_MATRIX_MODE = glcanvasc.GL_MATRIX_MODE +GL_MAX_ATTRIB_STACK_DEPTH = glcanvasc.GL_MAX_ATTRIB_STACK_DEPTH +GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = glcanvasc.GL_MAX_CLIENT_ATTRIB_STACK_DEPTH +GL_MAX_CLIP_PLANES = glcanvasc.GL_MAX_CLIP_PLANES +GL_MAX_ELEMENTS_INDICES_WIN = glcanvasc.GL_MAX_ELEMENTS_INDICES_WIN +GL_MAX_ELEMENTS_VERTICES_WIN = glcanvasc.GL_MAX_ELEMENTS_VERTICES_WIN +GL_MAX_EVAL_ORDER = glcanvasc.GL_MAX_EVAL_ORDER +GL_MAX_LIGHTS = glcanvasc.GL_MAX_LIGHTS +GL_MAX_LIST_NESTING = glcanvasc.GL_MAX_LIST_NESTING +GL_MAX_MODELVIEW_STACK_DEPTH = glcanvasc.GL_MAX_MODELVIEW_STACK_DEPTH +GL_MAX_NAME_STACK_DEPTH = glcanvasc.GL_MAX_NAME_STACK_DEPTH +GL_MAX_PIXEL_MAP_TABLE = glcanvasc.GL_MAX_PIXEL_MAP_TABLE +GL_MAX_PROJECTION_STACK_DEPTH = glcanvasc.GL_MAX_PROJECTION_STACK_DEPTH +GL_MAX_TEXTURE_SIZE = glcanvasc.GL_MAX_TEXTURE_SIZE +GL_MAX_TEXTURE_STACK_DEPTH = glcanvasc.GL_MAX_TEXTURE_STACK_DEPTH +GL_MAX_VIEWPORT_DIMS = glcanvasc.GL_MAX_VIEWPORT_DIMS +GL_MODELVIEW = glcanvasc.GL_MODELVIEW +GL_MODELVIEW_MATRIX = glcanvasc.GL_MODELVIEW_MATRIX +GL_MODELVIEW_STACK_DEPTH = glcanvasc.GL_MODELVIEW_STACK_DEPTH +GL_MODULATE = glcanvasc.GL_MODULATE +GL_MULT = glcanvasc.GL_MULT +GL_N3F_V3F = glcanvasc.GL_N3F_V3F +GL_NAME_STACK_DEPTH = glcanvasc.GL_NAME_STACK_DEPTH +GL_NAND = glcanvasc.GL_NAND +GL_NEAREST = glcanvasc.GL_NEAREST +GL_NEAREST_MIPMAP_LINEAR = glcanvasc.GL_NEAREST_MIPMAP_LINEAR +GL_NEAREST_MIPMAP_NEAREST = glcanvasc.GL_NEAREST_MIPMAP_NEAREST +GL_NEVER = glcanvasc.GL_NEVER +GL_NICEST = glcanvasc.GL_NICEST +GL_NONE = glcanvasc.GL_NONE +GL_NOOP = glcanvasc.GL_NOOP +GL_NOR = glcanvasc.GL_NOR +GL_NORMALIZE = glcanvasc.GL_NORMALIZE +GL_NORMAL_ARRAY = glcanvasc.GL_NORMAL_ARRAY +GL_NORMAL_ARRAY_COUNT_EXT = glcanvasc.GL_NORMAL_ARRAY_COUNT_EXT +GL_NORMAL_ARRAY_EXT = glcanvasc.GL_NORMAL_ARRAY_EXT +GL_NORMAL_ARRAY_POINTER = glcanvasc.GL_NORMAL_ARRAY_POINTER +GL_NORMAL_ARRAY_POINTER_EXT = glcanvasc.GL_NORMAL_ARRAY_POINTER_EXT +GL_NORMAL_ARRAY_STRIDE = glcanvasc.GL_NORMAL_ARRAY_STRIDE +GL_NORMAL_ARRAY_STRIDE_EXT = glcanvasc.GL_NORMAL_ARRAY_STRIDE_EXT +GL_NORMAL_ARRAY_TYPE = glcanvasc.GL_NORMAL_ARRAY_TYPE +GL_NORMAL_ARRAY_TYPE_EXT = glcanvasc.GL_NORMAL_ARRAY_TYPE_EXT +GL_NOTEQUAL = glcanvasc.GL_NOTEQUAL +GL_NO_ERROR = glcanvasc.GL_NO_ERROR +GL_OBJECT_LINEAR = glcanvasc.GL_OBJECT_LINEAR +GL_OBJECT_PLANE = glcanvasc.GL_OBJECT_PLANE +GL_ONE = glcanvasc.GL_ONE +GL_ONE_MINUS_DST_ALPHA = glcanvasc.GL_ONE_MINUS_DST_ALPHA +GL_ONE_MINUS_DST_COLOR = glcanvasc.GL_ONE_MINUS_DST_COLOR +GL_ONE_MINUS_SRC_ALPHA = glcanvasc.GL_ONE_MINUS_SRC_ALPHA +GL_ONE_MINUS_SRC_COLOR = glcanvasc.GL_ONE_MINUS_SRC_COLOR +GL_OR = glcanvasc.GL_OR +GL_ORDER = glcanvasc.GL_ORDER +GL_OR_INVERTED = glcanvasc.GL_OR_INVERTED +GL_OR_REVERSE = glcanvasc.GL_OR_REVERSE +GL_OUT_OF_MEMORY = glcanvasc.GL_OUT_OF_MEMORY +GL_PACK_ALIGNMENT = glcanvasc.GL_PACK_ALIGNMENT +GL_PACK_LSB_FIRST = glcanvasc.GL_PACK_LSB_FIRST +GL_PACK_ROW_LENGTH = glcanvasc.GL_PACK_ROW_LENGTH +GL_PACK_SKIP_PIXELS = glcanvasc.GL_PACK_SKIP_PIXELS +GL_PACK_SKIP_ROWS = glcanvasc.GL_PACK_SKIP_ROWS +GL_PACK_SWAP_BYTES = glcanvasc.GL_PACK_SWAP_BYTES +GL_PASS_THROUGH_TOKEN = glcanvasc.GL_PASS_THROUGH_TOKEN +GL_PERSPECTIVE_CORRECTION_HINT = glcanvasc.GL_PERSPECTIVE_CORRECTION_HINT +GL_PHONG_HINT_WIN = glcanvasc.GL_PHONG_HINT_WIN +GL_PHONG_WIN = glcanvasc.GL_PHONG_WIN +GL_PIXEL_MAP_A_TO_A = glcanvasc.GL_PIXEL_MAP_A_TO_A +GL_PIXEL_MAP_A_TO_A_SIZE = glcanvasc.GL_PIXEL_MAP_A_TO_A_SIZE +GL_PIXEL_MAP_B_TO_B = glcanvasc.GL_PIXEL_MAP_B_TO_B +GL_PIXEL_MAP_B_TO_B_SIZE = glcanvasc.GL_PIXEL_MAP_B_TO_B_SIZE +GL_PIXEL_MAP_G_TO_G = glcanvasc.GL_PIXEL_MAP_G_TO_G +GL_PIXEL_MAP_G_TO_G_SIZE = glcanvasc.GL_PIXEL_MAP_G_TO_G_SIZE +GL_PIXEL_MAP_I_TO_A = glcanvasc.GL_PIXEL_MAP_I_TO_A +GL_PIXEL_MAP_I_TO_A_SIZE = glcanvasc.GL_PIXEL_MAP_I_TO_A_SIZE +GL_PIXEL_MAP_I_TO_B = glcanvasc.GL_PIXEL_MAP_I_TO_B +GL_PIXEL_MAP_I_TO_B_SIZE = glcanvasc.GL_PIXEL_MAP_I_TO_B_SIZE +GL_PIXEL_MAP_I_TO_G = glcanvasc.GL_PIXEL_MAP_I_TO_G +GL_PIXEL_MAP_I_TO_G_SIZE = glcanvasc.GL_PIXEL_MAP_I_TO_G_SIZE +GL_PIXEL_MAP_I_TO_I = glcanvasc.GL_PIXEL_MAP_I_TO_I +GL_PIXEL_MAP_I_TO_I_SIZE = glcanvasc.GL_PIXEL_MAP_I_TO_I_SIZE +GL_PIXEL_MAP_I_TO_R = glcanvasc.GL_PIXEL_MAP_I_TO_R +GL_PIXEL_MAP_I_TO_R_SIZE = glcanvasc.GL_PIXEL_MAP_I_TO_R_SIZE +GL_PIXEL_MAP_R_TO_R = glcanvasc.GL_PIXEL_MAP_R_TO_R +GL_PIXEL_MAP_R_TO_R_SIZE = glcanvasc.GL_PIXEL_MAP_R_TO_R_SIZE +GL_PIXEL_MAP_S_TO_S = glcanvasc.GL_PIXEL_MAP_S_TO_S +GL_PIXEL_MAP_S_TO_S_SIZE = glcanvasc.GL_PIXEL_MAP_S_TO_S_SIZE +GL_PIXEL_MODE_BIT = glcanvasc.GL_PIXEL_MODE_BIT +GL_POINT = glcanvasc.GL_POINT +GL_POINTS = glcanvasc.GL_POINTS +GL_POINT_BIT = glcanvasc.GL_POINT_BIT +GL_POINT_SIZE = glcanvasc.GL_POINT_SIZE +GL_POINT_SIZE_GRANULARITY = glcanvasc.GL_POINT_SIZE_GRANULARITY +GL_POINT_SIZE_RANGE = glcanvasc.GL_POINT_SIZE_RANGE +GL_POINT_SMOOTH = glcanvasc.GL_POINT_SMOOTH +GL_POINT_SMOOTH_HINT = glcanvasc.GL_POINT_SMOOTH_HINT +GL_POINT_TOKEN = glcanvasc.GL_POINT_TOKEN +GL_POLYGON = glcanvasc.GL_POLYGON +GL_POLYGON_BIT = glcanvasc.GL_POLYGON_BIT +GL_POLYGON_MODE = glcanvasc.GL_POLYGON_MODE +GL_POLYGON_OFFSET_FACTOR = glcanvasc.GL_POLYGON_OFFSET_FACTOR +GL_POLYGON_OFFSET_FILL = glcanvasc.GL_POLYGON_OFFSET_FILL +GL_POLYGON_OFFSET_LINE = glcanvasc.GL_POLYGON_OFFSET_LINE +GL_POLYGON_OFFSET_POINT = glcanvasc.GL_POLYGON_OFFSET_POINT +GL_POLYGON_OFFSET_UNITS = glcanvasc.GL_POLYGON_OFFSET_UNITS +GL_POLYGON_SMOOTH = glcanvasc.GL_POLYGON_SMOOTH +GL_POLYGON_SMOOTH_HINT = glcanvasc.GL_POLYGON_SMOOTH_HINT +GL_POLYGON_STIPPLE = glcanvasc.GL_POLYGON_STIPPLE +GL_POLYGON_STIPPLE_BIT = glcanvasc.GL_POLYGON_STIPPLE_BIT +GL_POLYGON_TOKEN = glcanvasc.GL_POLYGON_TOKEN +GL_POSITION = glcanvasc.GL_POSITION +GL_PROJECTION = glcanvasc.GL_PROJECTION +GL_PROJECTION_MATRIX = glcanvasc.GL_PROJECTION_MATRIX +GL_PROJECTION_STACK_DEPTH = glcanvasc.GL_PROJECTION_STACK_DEPTH +GL_PROXY_TEXTURE_1D = glcanvasc.GL_PROXY_TEXTURE_1D +GL_PROXY_TEXTURE_2D = glcanvasc.GL_PROXY_TEXTURE_2D +GL_Q = glcanvasc.GL_Q +GL_QUADRATIC_ATTENUATION = glcanvasc.GL_QUADRATIC_ATTENUATION +GL_QUADS = glcanvasc.GL_QUADS +GL_QUAD_STRIP = glcanvasc.GL_QUAD_STRIP +GL_R = glcanvasc.GL_R +GL_R3_G3_B2 = glcanvasc.GL_R3_G3_B2 +GL_READ_BUFFER = glcanvasc.GL_READ_BUFFER +GL_RED = glcanvasc.GL_RED +GL_RED_BIAS = glcanvasc.GL_RED_BIAS +GL_RED_BITS = glcanvasc.GL_RED_BITS +GL_RED_SCALE = glcanvasc.GL_RED_SCALE +GL_RENDER = glcanvasc.GL_RENDER +GL_RENDERER = glcanvasc.GL_RENDERER +GL_RENDER_MODE = glcanvasc.GL_RENDER_MODE +GL_REPEAT = glcanvasc.GL_REPEAT +GL_REPLACE = glcanvasc.GL_REPLACE +GL_RETURN = glcanvasc.GL_RETURN +GL_RGB = glcanvasc.GL_RGB +GL_RGB10 = glcanvasc.GL_RGB10 +GL_RGB10_A2 = glcanvasc.GL_RGB10_A2 +GL_RGB12 = glcanvasc.GL_RGB12 +GL_RGB16 = glcanvasc.GL_RGB16 +GL_RGB4 = glcanvasc.GL_RGB4 +GL_RGB5 = glcanvasc.GL_RGB5 +GL_RGB5_A1 = glcanvasc.GL_RGB5_A1 +GL_RGB8 = glcanvasc.GL_RGB8 +GL_RGBA = glcanvasc.GL_RGBA +GL_RGBA12 = glcanvasc.GL_RGBA12 +GL_RGBA16 = glcanvasc.GL_RGBA16 +GL_RGBA2 = glcanvasc.GL_RGBA2 +GL_RGBA4 = glcanvasc.GL_RGBA4 +GL_RGBA8 = glcanvasc.GL_RGBA8 +GL_RGBA_MODE = glcanvasc.GL_RGBA_MODE +GL_RIGHT = glcanvasc.GL_RIGHT +GL_S = glcanvasc.GL_S +GL_SCISSOR_BIT = glcanvasc.GL_SCISSOR_BIT +GL_SCISSOR_BOX = glcanvasc.GL_SCISSOR_BOX +GL_SCISSOR_TEST = glcanvasc.GL_SCISSOR_TEST +GL_SELECT = glcanvasc.GL_SELECT +GL_SELECTION_BUFFER_POINTER = glcanvasc.GL_SELECTION_BUFFER_POINTER +GL_SELECTION_BUFFER_SIZE = glcanvasc.GL_SELECTION_BUFFER_SIZE +GL_SET = glcanvasc.GL_SET +GL_SHADE_MODEL = glcanvasc.GL_SHADE_MODEL +GL_SHININESS = glcanvasc.GL_SHININESS +GL_SHORT = glcanvasc.GL_SHORT +GL_SMOOTH = glcanvasc.GL_SMOOTH +GL_SPECULAR = glcanvasc.GL_SPECULAR +GL_SPHERE_MAP = glcanvasc.GL_SPHERE_MAP +GL_SPOT_CUTOFF = glcanvasc.GL_SPOT_CUTOFF +GL_SPOT_DIRECTION = glcanvasc.GL_SPOT_DIRECTION +GL_SPOT_EXPONENT = glcanvasc.GL_SPOT_EXPONENT +GL_SRC_ALPHA = glcanvasc.GL_SRC_ALPHA +GL_SRC_ALPHA_SATURATE = glcanvasc.GL_SRC_ALPHA_SATURATE +GL_SRC_COLOR = glcanvasc.GL_SRC_COLOR +GL_STACK_OVERFLOW = glcanvasc.GL_STACK_OVERFLOW +GL_STACK_UNDERFLOW = glcanvasc.GL_STACK_UNDERFLOW +GL_STENCIL = glcanvasc.GL_STENCIL +GL_STENCIL_BITS = glcanvasc.GL_STENCIL_BITS +GL_STENCIL_BUFFER_BIT = glcanvasc.GL_STENCIL_BUFFER_BIT +GL_STENCIL_CLEAR_VALUE = glcanvasc.GL_STENCIL_CLEAR_VALUE +GL_STENCIL_FAIL = glcanvasc.GL_STENCIL_FAIL +GL_STENCIL_FUNC = glcanvasc.GL_STENCIL_FUNC +GL_STENCIL_INDEX = glcanvasc.GL_STENCIL_INDEX +GL_STENCIL_PASS_DEPTH_FAIL = glcanvasc.GL_STENCIL_PASS_DEPTH_FAIL +GL_STENCIL_PASS_DEPTH_PASS = glcanvasc.GL_STENCIL_PASS_DEPTH_PASS +GL_STENCIL_REF = glcanvasc.GL_STENCIL_REF +GL_STENCIL_TEST = glcanvasc.GL_STENCIL_TEST +GL_STENCIL_VALUE_MASK = glcanvasc.GL_STENCIL_VALUE_MASK +GL_STENCIL_WRITEMASK = glcanvasc.GL_STENCIL_WRITEMASK +GL_STEREO = glcanvasc.GL_STEREO +GL_SUBPIXEL_BITS = glcanvasc.GL_SUBPIXEL_BITS +GL_T = glcanvasc.GL_T +GL_T2F_C3F_V3F = glcanvasc.GL_T2F_C3F_V3F +GL_T2F_C4F_N3F_V3F = glcanvasc.GL_T2F_C4F_N3F_V3F +GL_T2F_C4UB_V3F = glcanvasc.GL_T2F_C4UB_V3F +GL_T2F_N3F_V3F = glcanvasc.GL_T2F_N3F_V3F +GL_T2F_V3F = glcanvasc.GL_T2F_V3F +GL_T4F_C4F_N3F_V4F = glcanvasc.GL_T4F_C4F_N3F_V4F +GL_T4F_V4F = glcanvasc.GL_T4F_V4F +GL_TEXTURE = glcanvasc.GL_TEXTURE +GL_TEXTURE_1D = glcanvasc.GL_TEXTURE_1D +GL_TEXTURE_2D = glcanvasc.GL_TEXTURE_2D +GL_TEXTURE_ALPHA_SIZE = glcanvasc.GL_TEXTURE_ALPHA_SIZE +GL_TEXTURE_BINDING_1D = glcanvasc.GL_TEXTURE_BINDING_1D +GL_TEXTURE_BINDING_2D = glcanvasc.GL_TEXTURE_BINDING_2D +GL_TEXTURE_BIT = glcanvasc.GL_TEXTURE_BIT +GL_TEXTURE_BLUE_SIZE = glcanvasc.GL_TEXTURE_BLUE_SIZE +GL_TEXTURE_BORDER = glcanvasc.GL_TEXTURE_BORDER +GL_TEXTURE_BORDER_COLOR = glcanvasc.GL_TEXTURE_BORDER_COLOR +GL_TEXTURE_COMPONENTS = glcanvasc.GL_TEXTURE_COMPONENTS +GL_TEXTURE_COORD_ARRAY = glcanvasc.GL_TEXTURE_COORD_ARRAY +GL_TEXTURE_COORD_ARRAY_COUNT_EXT = glcanvasc.GL_TEXTURE_COORD_ARRAY_COUNT_EXT +GL_TEXTURE_COORD_ARRAY_EXT = glcanvasc.GL_TEXTURE_COORD_ARRAY_EXT +GL_TEXTURE_COORD_ARRAY_POINTER = glcanvasc.GL_TEXTURE_COORD_ARRAY_POINTER +GL_TEXTURE_COORD_ARRAY_POINTER_EXT = glcanvasc.GL_TEXTURE_COORD_ARRAY_POINTER_EXT +GL_TEXTURE_COORD_ARRAY_SIZE = glcanvasc.GL_TEXTURE_COORD_ARRAY_SIZE +GL_TEXTURE_COORD_ARRAY_SIZE_EXT = glcanvasc.GL_TEXTURE_COORD_ARRAY_SIZE_EXT +GL_TEXTURE_COORD_ARRAY_STRIDE = glcanvasc.GL_TEXTURE_COORD_ARRAY_STRIDE +GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = glcanvasc.GL_TEXTURE_COORD_ARRAY_STRIDE_EXT +GL_TEXTURE_COORD_ARRAY_TYPE = glcanvasc.GL_TEXTURE_COORD_ARRAY_TYPE +GL_TEXTURE_COORD_ARRAY_TYPE_EXT = glcanvasc.GL_TEXTURE_COORD_ARRAY_TYPE_EXT +GL_TEXTURE_ENV = glcanvasc.GL_TEXTURE_ENV +GL_TEXTURE_ENV_COLOR = glcanvasc.GL_TEXTURE_ENV_COLOR +GL_TEXTURE_ENV_MODE = glcanvasc.GL_TEXTURE_ENV_MODE +GL_TEXTURE_GEN_MODE = glcanvasc.GL_TEXTURE_GEN_MODE +GL_TEXTURE_GEN_Q = glcanvasc.GL_TEXTURE_GEN_Q +GL_TEXTURE_GEN_R = glcanvasc.GL_TEXTURE_GEN_R +GL_TEXTURE_GEN_S = glcanvasc.GL_TEXTURE_GEN_S +GL_TEXTURE_GEN_T = glcanvasc.GL_TEXTURE_GEN_T +GL_TEXTURE_GREEN_SIZE = glcanvasc.GL_TEXTURE_GREEN_SIZE +GL_TEXTURE_HEIGHT = glcanvasc.GL_TEXTURE_HEIGHT +GL_TEXTURE_INTENSITY_SIZE = glcanvasc.GL_TEXTURE_INTENSITY_SIZE +GL_TEXTURE_INTERNAL_FORMAT = glcanvasc.GL_TEXTURE_INTERNAL_FORMAT +GL_TEXTURE_LUMINANCE_SIZE = glcanvasc.GL_TEXTURE_LUMINANCE_SIZE +GL_TEXTURE_MAG_FILTER = glcanvasc.GL_TEXTURE_MAG_FILTER +GL_TEXTURE_MATRIX = glcanvasc.GL_TEXTURE_MATRIX +GL_TEXTURE_MIN_FILTER = glcanvasc.GL_TEXTURE_MIN_FILTER +GL_TEXTURE_PRIORITY = glcanvasc.GL_TEXTURE_PRIORITY +GL_TEXTURE_RED_SIZE = glcanvasc.GL_TEXTURE_RED_SIZE +GL_TEXTURE_RESIDENT = glcanvasc.GL_TEXTURE_RESIDENT +GL_TEXTURE_STACK_DEPTH = glcanvasc.GL_TEXTURE_STACK_DEPTH +GL_TEXTURE_WIDTH = glcanvasc.GL_TEXTURE_WIDTH +GL_TEXTURE_WRAP_S = glcanvasc.GL_TEXTURE_WRAP_S +GL_TEXTURE_WRAP_T = glcanvasc.GL_TEXTURE_WRAP_T +GL_TRANSFORM_BIT = glcanvasc.GL_TRANSFORM_BIT +GL_TRIANGLES = glcanvasc.GL_TRIANGLES +GL_TRIANGLE_FAN = glcanvasc.GL_TRIANGLE_FAN +GL_TRIANGLE_STRIP = glcanvasc.GL_TRIANGLE_STRIP +GL_TRUE = glcanvasc.GL_TRUE +GL_UNPACK_ALIGNMENT = glcanvasc.GL_UNPACK_ALIGNMENT +GL_UNPACK_LSB_FIRST = glcanvasc.GL_UNPACK_LSB_FIRST +GL_UNPACK_ROW_LENGTH = glcanvasc.GL_UNPACK_ROW_LENGTH +GL_UNPACK_SKIP_PIXELS = glcanvasc.GL_UNPACK_SKIP_PIXELS +GL_UNPACK_SKIP_ROWS = glcanvasc.GL_UNPACK_SKIP_ROWS +GL_UNPACK_SWAP_BYTES = glcanvasc.GL_UNPACK_SWAP_BYTES +GL_UNSIGNED_BYTE = glcanvasc.GL_UNSIGNED_BYTE +GL_UNSIGNED_INT = glcanvasc.GL_UNSIGNED_INT +GL_UNSIGNED_SHORT = glcanvasc.GL_UNSIGNED_SHORT +GL_V2F = glcanvasc.GL_V2F +GL_V3F = glcanvasc.GL_V3F +GL_VENDOR = glcanvasc.GL_VENDOR +GL_VERSION = glcanvasc.GL_VERSION +GL_VERTEX_ARRAY = glcanvasc.GL_VERTEX_ARRAY +GL_VERTEX_ARRAY_COUNT_EXT = glcanvasc.GL_VERTEX_ARRAY_COUNT_EXT +GL_VERTEX_ARRAY_EXT = glcanvasc.GL_VERTEX_ARRAY_EXT +GL_VERTEX_ARRAY_POINTER = glcanvasc.GL_VERTEX_ARRAY_POINTER +GL_VERTEX_ARRAY_POINTER_EXT = glcanvasc.GL_VERTEX_ARRAY_POINTER_EXT +GL_VERTEX_ARRAY_SIZE = glcanvasc.GL_VERTEX_ARRAY_SIZE +GL_VERTEX_ARRAY_SIZE_EXT = glcanvasc.GL_VERTEX_ARRAY_SIZE_EXT +GL_VERTEX_ARRAY_STRIDE = glcanvasc.GL_VERTEX_ARRAY_STRIDE +GL_VERTEX_ARRAY_STRIDE_EXT = glcanvasc.GL_VERTEX_ARRAY_STRIDE_EXT +GL_VERTEX_ARRAY_TYPE = glcanvasc.GL_VERTEX_ARRAY_TYPE +GL_VERTEX_ARRAY_TYPE_EXT = glcanvasc.GL_VERTEX_ARRAY_TYPE_EXT +GL_VIEWPORT = glcanvasc.GL_VIEWPORT +GL_VIEWPORT_BIT = glcanvasc.GL_VIEWPORT_BIT +GL_WIN_draw_range_elements = glcanvasc.GL_WIN_draw_range_elements +GL_WIN_swap_hint = glcanvasc.GL_WIN_swap_hint +GL_XOR = glcanvasc.GL_XOR +GL_ZERO = glcanvasc.GL_ZERO +GL_ZOOM_X = glcanvasc.GL_ZOOM_X +GL_ZOOM_Y = glcanvasc.GL_ZOOM_Y diff --git a/utils/wxPython/src/msw/image.cpp b/utils/wxPython/src/msw/image.cpp new file mode 100644 index 0000000000..e3bde142dd --- /dev/null +++ b/utils/wxPython/src/msw/image.cpp @@ -0,0 +1,1588 @@ +/* + * FILE : msw/image.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 +#include +/* 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 initimagec + +#define SWIG_name "imagec" + +#include "helpers.h" +#include + +static PyObject* l_output_helper(PyObject* target, PyObject* o) { + PyObject* o2; + if (!target) { + target = o; + } else if (target == Py_None) { + Py_DECREF(Py_None); + target = o; + } else { + if (!PyList_Check(target)) { + o2 = target; + target = PyList_New(0); + PyList_Append(target, o2); + Py_XDECREF(o2); + } + PyList_Append(target,o); + Py_XDECREF(o); + } + return target; +} + +static PyObject* t_output_helper(PyObject* target, PyObject* o) { + PyObject* o2; + PyObject* o3; + + if (!target) { + target = o; + } else if (target == Py_None) { + Py_DECREF(Py_None); + target = o; + } else { + if (!PyTuple_Check(target)) { + o2 = target; + target = PyTuple_New(1); + PyTuple_SetItem(target, 0, o2); + } + o3 = PyTuple_New(1); + PyTuple_SetItem(o3, 0, o); + + o2 = target; + target = PySequence_Concat(o2, o3); + Py_DECREF(o2); + Py_DECREF(o3); + } + return target; +} + + +extern byte* byte_LIST_helper(PyObject* source); +extern int* int_LIST_helper(PyObject* source); +extern long* long_LIST_helper(PyObject* source); +extern char** string_LIST_helper(PyObject* source); +extern wxPoint* wxPoint_LIST_helper(PyObject* source); +extern wxBitmap** wxBitmap_LIST_helper(PyObject* source); +extern wxString* wxString_LIST_helper(PyObject* source); +extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source); + + +static char* wxStringErrorMsg = "string type is required for parameter"; + + wxImage* wxNullImage() { + return new wxImage; + } + + wxImage* wxEmptyImage(int width, int height) { + return new wxImage(width, height); + } + + wxImage* wxImageFromMime(const wxString& name, const wxString& mimetype) { + return new wxImage(name, mimetype); + } + + wxImage* wxImageFromBitmap(const wxBitmap &bitmap) { + return new wxImage(bitmap); + } + + void wxImage_AddHandler(wxImageHandler *handler) { + wxImage::AddHandler(handler); + } +static PyObject *_wrap_wxNullImage(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _result; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,":wxNullImage")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImage *)wxNullImage(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static PyObject *_wrap_wxEmptyImage(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _result; + int _arg0; + int _arg1; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"ii:wxEmptyImage",&_arg0,&_arg1)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImage *)wxEmptyImage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static PyObject *_wrap_wxImageFromMime(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _result; + wxString * _arg0; + wxString * _arg1; + PyObject * _obj0 = 0; + PyObject * _obj1 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"OO:wxImageFromMime",&_obj0,&_obj1)) + return NULL; +{ + if (!PyString_Check(_obj0)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); +} +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImage *)wxImageFromMime(*_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); + _resultobj = Py_BuildValue("s",_ptemp); +{ + if (_obj0) + delete _arg0; +} +{ + if (_obj1) + delete _arg1; +} + return _resultobj; +} + +static PyObject *_wrap_wxImageFromBitmap(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _result; + wxBitmap * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImageFromBitmap",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxBitmap_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageFromBitmap. Expected _wxBitmap_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImage *)wxImageFromBitmap(*_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static PyObject *_wrap_wxImage_AddHandler(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImageHandler * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_AddHandler",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_AddHandler. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImage_AddHandler(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define new_wxImageHandler() (new wxImageHandler()) +static PyObject *_wrap_new_wxImageHandler(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImageHandler * _result; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,":new_wxImageHandler")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImageHandler *)new_wxImageHandler(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageHandler_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxImageHandler_GetName(_swigobj) (_swigobj->GetName()) +static PyObject *_wrap_wxImageHandler_GetName(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxString * _result; + wxImageHandler * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImageHandler_GetName",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetName. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxImageHandler_GetName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); +} +{ + delete _result; +} + return _resultobj; +} + +#define wxImageHandler_GetExtension(_swigobj) (_swigobj->GetExtension()) +static PyObject *_wrap_wxImageHandler_GetExtension(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxString * _result; + wxImageHandler * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImageHandler_GetExtension",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetExtension. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxImageHandler_GetExtension(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); +} +{ + delete _result; +} + return _resultobj; +} + +#define wxImageHandler_GetType(_swigobj) (_swigobj->GetType()) +static PyObject *_wrap_wxImageHandler_GetType(PyObject *self, PyObject *args) { + PyObject * _resultobj; + long _result; + wxImageHandler * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImageHandler_GetType",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetType. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxImageHandler_GetType(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); + return _resultobj; +} + +#define wxImageHandler_GetMimeType(_swigobj) (_swigobj->GetMimeType()) +static PyObject *_wrap_wxImageHandler_GetMimeType(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxString * _result; + wxImageHandler * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImageHandler_GetMimeType",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetMimeType. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxImageHandler_GetMimeType(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); +} +{ + delete _result; +} + return _resultobj; +} + +#define wxImageHandler_SetName(_swigobj,_swigarg0) (_swigobj->SetName(_swigarg0)) +static PyObject *_wrap_wxImageHandler_SetName(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImageHandler * _arg0; + wxString * _arg1; + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sO:wxImageHandler_SetName",&_argc0,&_obj1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetName. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImageHandler_SetName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; +{ + if (_obj1) + delete _arg1; +} + return _resultobj; +} + +#define wxImageHandler_SetExtension(_swigobj,_swigarg0) (_swigobj->SetExtension(_swigarg0)) +static PyObject *_wrap_wxImageHandler_SetExtension(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImageHandler * _arg0; + wxString * _arg1; + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sO:wxImageHandler_SetExtension",&_argc0,&_obj1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetExtension. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImageHandler_SetExtension(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; +{ + if (_obj1) + delete _arg1; +} + return _resultobj; +} + +#define wxImageHandler_SetType(_swigobj,_swigarg0) (_swigobj->SetType(_swigarg0)) +static PyObject *_wrap_wxImageHandler_SetType(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImageHandler * _arg0; + long _arg1; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sl:wxImageHandler_SetType",&_argc0,&_arg1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetType. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImageHandler_SetType(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImageHandler_SetMimeType(_swigobj,_swigarg0) (_swigobj->SetMimeType(_swigarg0)) +static PyObject *_wrap_wxImageHandler_SetMimeType(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImageHandler * _arg0; + wxString * _arg1; + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sO:wxImageHandler_SetMimeType",&_argc0,&_obj1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImageHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetMimeType. Expected _wxImageHandler_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImageHandler_SetMimeType(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; +{ + if (_obj1) + delete _arg1; +} + return _resultobj; +} + +static void *SwigwxPNGHandlerTowxImageHandler(void *ptr) { + wxPNGHandler *src; + wxImageHandler *dest; + src = (wxPNGHandler *) ptr; + dest = (wxImageHandler *) src; + return (void *) dest; +} + +#define new_wxPNGHandler() (new wxPNGHandler()) +static PyObject *_wrap_new_wxPNGHandler(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxPNGHandler * _result; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,":new_wxPNGHandler")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPNGHandler *)new_wxPNGHandler(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPNGHandler_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static void *SwigwxJPEGHandlerTowxImageHandler(void *ptr) { + wxJPEGHandler *src; + wxImageHandler *dest; + src = (wxJPEGHandler *) ptr; + dest = (wxImageHandler *) src; + return (void *) dest; +} + +#define new_wxJPEGHandler() (new wxJPEGHandler()) +static PyObject *_wrap_new_wxJPEGHandler(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxJPEGHandler * _result; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,":new_wxJPEGHandler")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxJPEGHandler *)new_wxJPEGHandler(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxJPEGHandler_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static void *SwigwxBMPHandlerTowxImageHandler(void *ptr) { + wxBMPHandler *src; + wxImageHandler *dest; + src = (wxBMPHandler *) ptr; + dest = (wxImageHandler *) src; + return (void *) dest; +} + +#define new_wxBMPHandler() (new wxBMPHandler()) +static PyObject *_wrap_new_wxBMPHandler(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxBMPHandler * _result; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,":new_wxBMPHandler")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBMPHandler *)new_wxBMPHandler(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBMPHandler_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +static void *SwigwxGIFHandlerTowxImageHandler(void *ptr) { + wxGIFHandler *src; + wxImageHandler *dest; + src = (wxGIFHandler *) ptr; + dest = (wxImageHandler *) src; + return (void *) dest; +} + +#define new_wxGIFHandler() (new wxGIFHandler()) +static PyObject *_wrap_new_wxGIFHandler(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxGIFHandler * _result; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,":new_wxGIFHandler")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGIFHandler *)new_wxGIFHandler(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGIFHandler_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define new_wxImage(_swigarg0,_swigarg1) (new wxImage(_swigarg0,_swigarg1)) +static PyObject *_wrap_new_wxImage(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _result; + wxString * _arg0; + long _arg1 = (wxBITMAP_TYPE_PNG); + PyObject * _obj0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"O|l:new_wxImage",&_obj0,&_arg1)) + return NULL; +{ + if (!PyString_Check(_obj0)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImage *)new_wxImage(*_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p"); + _resultobj = Py_BuildValue("s",_ptemp); +{ + if (_obj0) + delete _arg0; +} + return _resultobj; +} + +#define delete_wxImage(_swigobj) (delete _swigobj) +static PyObject *_wrap_delete_wxImage(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:delete_wxImage",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxImage. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxImage(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImage_ConvertToBitmap(_swigobj) (_swigobj->ConvertToBitmap()) +static PyObject *_wrap_wxImage_ConvertToBitmap(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxBitmap * _result; + wxImage * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_ConvertToBitmap",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToBitmap. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxBitmap (wxImage_ConvertToBitmap(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxImage_Create(_swigobj,_swigarg0,_swigarg1) (_swigobj->Create(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_Create(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _arg0; + int _arg1; + int _arg2; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sii:wxImage_Create",&_argc0,&_arg1,&_arg2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Create. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImage_Create(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImage_Destroy(_swigobj) (_swigobj->Destroy()) +static PyObject *_wrap_wxImage_Destroy(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_Destroy",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Destroy. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImage_Destroy(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImage_Scale(_swigobj,_swigarg0,_swigarg1) (_swigobj->Scale(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_Scale(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _result; + wxImage * _arg0; + int _arg1; + int _arg2; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"sii:wxImage_Scale",&_argc0,&_arg1,&_arg2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Scale. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxImage (wxImage_Scale(_arg0,_arg1,_arg2)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxImage_SetRGB(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (_swigobj->SetRGB(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)) +static PyObject *_wrap_wxImage_SetRGB(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _arg0; + int _arg1; + int _arg2; + unsigned char _arg3; + unsigned char _arg4; + unsigned char _arg5; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"siibbb:wxImage_SetRGB",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetRGB. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImage_SetRGB(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImage_GetRed(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetRed(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_GetRed(PyObject *self, PyObject *args) { + PyObject * _resultobj; + unsigned char _result; + wxImage * _arg0; + int _arg1; + int _arg2; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sii:wxImage_GetRed",&_argc0,&_arg1,&_arg2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetRed. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxImage_GetRed(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +#define wxImage_GetGreen(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetGreen(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_GetGreen(PyObject *self, PyObject *args) { + PyObject * _resultobj; + unsigned char _result; + wxImage * _arg0; + int _arg1; + int _arg2; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sii:wxImage_GetGreen",&_argc0,&_arg1,&_arg2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetGreen. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxImage_GetGreen(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +#define wxImage_GetBlue(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetBlue(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_GetBlue(PyObject *self, PyObject *args) { + PyObject * _resultobj; + unsigned char _result; + wxImage * _arg0; + int _arg1; + int _arg2; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sii:wxImage_GetBlue",&_argc0,&_arg1,&_arg2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetBlue. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxImage_GetBlue(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +#define wxImage_LoadFile(_swigobj,_swigarg0,_swigarg1) (_swigobj->LoadFile(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_LoadFile(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxImage * _arg0; + wxString * _arg1; + long _arg2 = (wxBITMAP_TYPE_PNG); + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sO|l:wxImage_LoadFile",&_argc0,&_obj1,&_arg2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadFile. Expected _wxImage_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImage_LoadFile(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); +{ + if (_obj1) + delete _arg1; +} + return _resultobj; +} + +#define wxImage_LoadMimeFile(_swigobj,_swigarg0,_swigarg1) (_swigobj->LoadFile(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_LoadMimeFile(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxImage * _arg0; + wxString * _arg1; + wxString * _arg2; + char * _argc0 = 0; + PyObject * _obj1 = 0; + PyObject * _obj2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sOO:wxImage_LoadMimeFile",&_argc0,&_obj1,&_obj2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeFile. Expected _wxImage_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + if (!PyString_Check(_obj2)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImage_LoadMimeFile(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); +{ + if (_obj1) + delete _arg1; +} +{ + if (_obj2) + delete _arg2; +} + return _resultobj; +} + +#define wxImage_SaveFile(_swigobj,_swigarg0,_swigarg1) (_swigobj->SaveFile(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_SaveFile(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxImage * _arg0; + wxString * _arg1; + int _arg2; + char * _argc0 = 0; + PyObject * _obj1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sOi:wxImage_SaveFile",&_argc0,&_obj1,&_arg2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveFile. Expected _wxImage_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImage_SaveFile(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); +{ + if (_obj1) + delete _arg1; +} + return _resultobj; +} + +#define wxImage_SaveMimeFile(_swigobj,_swigarg0,_swigarg1) (_swigobj->SaveFile(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxImage_SaveMimeFile(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxImage * _arg0; + wxString * _arg1; + wxString * _arg2; + char * _argc0 = 0; + PyObject * _obj1 = 0; + PyObject * _obj2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sOO:wxImage_SaveMimeFile",&_argc0,&_obj1,&_obj2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveMimeFile. Expected _wxImage_p."); + return NULL; + } + } +{ + if (!PyString_Check(_obj1)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); +} +{ + if (!PyString_Check(_obj2)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); +} +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImage_SaveMimeFile(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); +{ + if (_obj1) + delete _arg1; +} +{ + if (_obj2) + delete _arg2; +} + return _resultobj; +} + +#define wxImage_Ok(_swigobj) (_swigobj->Ok()) +static PyObject *_wrap_wxImage_Ok(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_Ok",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Ok. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImage_Ok(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxImage_GetWidth(_swigobj) (_swigobj->GetWidth()) +static PyObject *_wrap_wxImage_GetWidth(PyObject *self, PyObject *args) { + PyObject * _resultobj; + int _result; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_GetWidth",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetWidth. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxImage_GetWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxImage_GetHeight(_swigobj) (_swigobj->GetHeight()) +static PyObject *_wrap_wxImage_GetHeight(PyObject *self, PyObject *args) { + PyObject * _resultobj; + int _result; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_GetHeight",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetHeight. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxImage_GetHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxImage_GetData(_swigobj) (_swigobj->GetData()) +static PyObject *_wrap_wxImage_GetData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + unsigned char * _result; + wxImage * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_GetData",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetData. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char *)wxImage_GetData(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_unsigned_char_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxImage_SetData(_swigobj,_swigarg0) (_swigobj->SetData(_swigarg0)) +static PyObject *_wrap_wxImage_SetData(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _arg0; + unsigned char * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxImage_SetData",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetData. Expected _wxImage_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_unsigned_char_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxImage_SetData. Expected _unsigned_char_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImage_SetData(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImage_SetMaskColour(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->SetMaskColour(_swigarg0,_swigarg1,_swigarg2)) +static PyObject *_wrap_wxImage_SetMaskColour(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _arg0; + unsigned char _arg1; + unsigned char _arg2; + unsigned char _arg3; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"sbbb:wxImage_SetMaskColour",&_argc0,&_arg1,&_arg2,&_arg3)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMaskColour. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImage_SetMaskColour(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImage_GetMaskRed(_swigobj) (_swigobj->GetMaskRed()) +static PyObject *_wrap_wxImage_GetMaskRed(PyObject *self, PyObject *args) { + PyObject * _resultobj; + unsigned char _result; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_GetMaskRed",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskRed. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxImage_GetMaskRed(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +#define wxImage_GetMaskGreen(_swigobj) (_swigobj->GetMaskGreen()) +static PyObject *_wrap_wxImage_GetMaskGreen(PyObject *self, PyObject *args) { + PyObject * _resultobj; + unsigned char _result; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_GetMaskGreen",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskGreen. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxImage_GetMaskGreen(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +#define wxImage_GetMaskBlue(_swigobj) (_swigobj->GetMaskBlue()) +static PyObject *_wrap_wxImage_GetMaskBlue(PyObject *self, PyObject *args) { + PyObject * _resultobj; + unsigned char _result; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_GetMaskBlue",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskBlue. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (unsigned char )wxImage_GetMaskBlue(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("b",_result); + return _resultobj; +} + +#define wxImage_SetMask(_swigobj,_swigarg0) (_swigobj->SetMask(_swigarg0)) +static PyObject *_wrap_wxImage_SetMask(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxImage * _arg0; + bool _arg1 = (1); + char * _argc0 = 0; + int tempbool1; + + self = self; + if(!PyArg_ParseTuple(args,"s|i:wxImage_SetMask",&_argc0,&tempbool1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMask. Expected _wxImage_p."); + return NULL; + } + } + _arg1 = (bool ) tempbool1; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxImage_SetMask(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxImage_HasMask(_swigobj) (_swigobj->HasMask()) +static PyObject *_wrap_wxImage_HasMask(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxImage * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxImage_HasMask",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxImage_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasMask. Expected _wxImage_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxImage_HasMask(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyMethodDef imagecMethods[] = { + { "wxImage_HasMask", _wrap_wxImage_HasMask, 1 }, + { "wxImage_SetMask", _wrap_wxImage_SetMask, 1 }, + { "wxImage_GetMaskBlue", _wrap_wxImage_GetMaskBlue, 1 }, + { "wxImage_GetMaskGreen", _wrap_wxImage_GetMaskGreen, 1 }, + { "wxImage_GetMaskRed", _wrap_wxImage_GetMaskRed, 1 }, + { "wxImage_SetMaskColour", _wrap_wxImage_SetMaskColour, 1 }, + { "wxImage_SetData", _wrap_wxImage_SetData, 1 }, + { "wxImage_GetData", _wrap_wxImage_GetData, 1 }, + { "wxImage_GetHeight", _wrap_wxImage_GetHeight, 1 }, + { "wxImage_GetWidth", _wrap_wxImage_GetWidth, 1 }, + { "wxImage_Ok", _wrap_wxImage_Ok, 1 }, + { "wxImage_SaveMimeFile", _wrap_wxImage_SaveMimeFile, 1 }, + { "wxImage_SaveFile", _wrap_wxImage_SaveFile, 1 }, + { "wxImage_LoadMimeFile", _wrap_wxImage_LoadMimeFile, 1 }, + { "wxImage_LoadFile", _wrap_wxImage_LoadFile, 1 }, + { "wxImage_GetBlue", _wrap_wxImage_GetBlue, 1 }, + { "wxImage_GetGreen", _wrap_wxImage_GetGreen, 1 }, + { "wxImage_GetRed", _wrap_wxImage_GetRed, 1 }, + { "wxImage_SetRGB", _wrap_wxImage_SetRGB, 1 }, + { "wxImage_Scale", _wrap_wxImage_Scale, 1 }, + { "wxImage_Destroy", _wrap_wxImage_Destroy, 1 }, + { "wxImage_Create", _wrap_wxImage_Create, 1 }, + { "wxImage_ConvertToBitmap", _wrap_wxImage_ConvertToBitmap, 1 }, + { "delete_wxImage", _wrap_delete_wxImage, 1 }, + { "new_wxImage", _wrap_new_wxImage, 1 }, + { "new_wxGIFHandler", _wrap_new_wxGIFHandler, 1 }, + { "new_wxBMPHandler", _wrap_new_wxBMPHandler, 1 }, + { "new_wxJPEGHandler", _wrap_new_wxJPEGHandler, 1 }, + { "new_wxPNGHandler", _wrap_new_wxPNGHandler, 1 }, + { "wxImageHandler_SetMimeType", _wrap_wxImageHandler_SetMimeType, 1 }, + { "wxImageHandler_SetType", _wrap_wxImageHandler_SetType, 1 }, + { "wxImageHandler_SetExtension", _wrap_wxImageHandler_SetExtension, 1 }, + { "wxImageHandler_SetName", _wrap_wxImageHandler_SetName, 1 }, + { "wxImageHandler_GetMimeType", _wrap_wxImageHandler_GetMimeType, 1 }, + { "wxImageHandler_GetType", _wrap_wxImageHandler_GetType, 1 }, + { "wxImageHandler_GetExtension", _wrap_wxImageHandler_GetExtension, 1 }, + { "wxImageHandler_GetName", _wrap_wxImageHandler_GetName, 1 }, + { "new_wxImageHandler", _wrap_new_wxImageHandler, 1 }, + { "wxImage_AddHandler", _wrap_wxImage_AddHandler, 1 }, + { "wxImageFromBitmap", _wrap_wxImageFromBitmap, 1 }, + { "wxImageFromMime", _wrap_wxImageFromMime, 1 }, + { "wxEmptyImage", _wrap_wxEmptyImage, 1 }, + { "wxNullImage", _wrap_wxNullImage, 1 }, + { NULL, NULL } +}; +static PyObject *SWIG_globals; +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT(void,initimagec)() { + PyObject *m, *d; + SWIG_globals = SWIG_newvarlink(); + m = Py_InitModule("imagec", imagecMethods); + 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_wxJPEGHandler","_wxJPEGHandler",0); + SWIG_RegisterMapping("_wxBMPHandler","_class_wxBMPHandler",0); + SWIG_RegisterMapping("_wxImage","_class_wxImage",0); + SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0); + SWIG_RegisterMapping("_wxGIFHandler","_class_wxGIFHandler",0); + SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0); + SWIG_RegisterMapping("_wxImageHandler","_class_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_class_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_class_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler); + SWIG_RegisterMapping("_wxImageHandler","_class_wxImageHandler",0); + SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0); + SWIG_RegisterMapping("_wxMask","_class_wxMask",0); + SWIG_RegisterMapping("_wxPNGHandler","_class_wxPNGHandler",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("_wxImageList","_class_wxImageList",0); + SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0); + SWIG_RegisterMapping("_wxDC","_class_wxDC",0); + SWIG_RegisterMapping("_class_wxBMPHandler","_wxBMPHandler",0); + SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0); + SWIG_RegisterMapping("_wxPrinterDC","_class_wxPrinterDC",0); + SWIG_RegisterMapping("_class_wxGIFHandler","_wxGIFHandler",0); + SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); + SWIG_RegisterMapping("_class_wxMask","_wxMask",0); + SWIG_RegisterMapping("_class_wxPNGHandler","_wxPNGHandler",0); + SWIG_RegisterMapping("_wxColour","_class_wxColour",0); + SWIG_RegisterMapping("_wxBrush","_class_wxBrush",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("_class_wxImage","_wxImage",0); + SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0); + SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0); + SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0); + SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0); + SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_EBool","_signed_int",0); + SWIG_RegisterMapping("_EBool","_int",0); + SWIG_RegisterMapping("_EBool","_wxWindowID",0); + SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0); + SWIG_RegisterMapping("_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("_class_wxPyTimer","_wxPyTimer",0); + SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",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("_wxScreenDC","_class_wxScreenDC",0); + SWIG_RegisterMapping("_WXTYPE","_short",0); + SWIG_RegisterMapping("_WXTYPE","_signed_short",0); + SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0); + SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0); + SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0); + SWIG_RegisterMapping("_unsigned_short","_short",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_wxWindowDC","_wxWindowDC",0); + SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0); + SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0); + SWIG_RegisterMapping("_class_wxImageHandler","_class_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_class_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_class_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler); + SWIG_RegisterMapping("_class_wxImageHandler","_wxImageHandler",0); + SWIG_RegisterMapping("_unsigned_char","_byte",0); + SWIG_RegisterMapping("_class_wxMetaFileDC","_wxMetaFileDC",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("_class_wxPen","_wxPen",0); + SWIG_RegisterMapping("_short","_WXTYPE",0); + SWIG_RegisterMapping("_short","_unsigned_short",0); + SWIG_RegisterMapping("_short","_signed_short",0); + SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0); + SWIG_RegisterMapping("_wxJPEGHandler","_class_wxJPEGHandler",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("_wxRegionIterator","_class_wxRegionIterator",0); + SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",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("_wxPalette","_class_wxPalette",0); + SWIG_RegisterMapping("_wxRegion","_class_wxRegion",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("_wxDash","_unsigned_long",0); + SWIG_RegisterMapping("_wxDash","_long",0); + SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0); +} diff --git a/utils/wxPython/src/msw/image.py b/utils/wxPython/src/msw/image.py new file mode 100644 index 0000000000..6743bf9b5c --- /dev/null +++ b/utils/wxPython/src/msw/image.py @@ -0,0 +1,226 @@ +# This file was created automatically by SWIG. +import imagec + +from misc import * + +from gdi import * +class wxImageHandlerPtr : + def __init__(self,this): + self.this = this + self.thisown = 0 + def GetName(self): + val = imagec.wxImageHandler_GetName(self.this) + return val + def GetExtension(self): + val = imagec.wxImageHandler_GetExtension(self.this) + return val + def GetType(self): + val = imagec.wxImageHandler_GetType(self.this) + return val + def GetMimeType(self): + val = imagec.wxImageHandler_GetMimeType(self.this) + return val + def SetName(self,arg0): + val = imagec.wxImageHandler_SetName(self.this,arg0) + return val + def SetExtension(self,arg0): + val = imagec.wxImageHandler_SetExtension(self.this,arg0) + return val + def SetType(self,arg0): + val = imagec.wxImageHandler_SetType(self.this,arg0) + return val + def SetMimeType(self,arg0): + val = imagec.wxImageHandler_SetMimeType(self.this,arg0) + return val + def __repr__(self): + return "" +class wxImageHandler(wxImageHandlerPtr): + def __init__(self) : + self.this = imagec.new_wxImageHandler() + self.thisown = 1 + + + + +class wxPNGHandlerPtr(wxImageHandlerPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __repr__(self): + return "" +class wxPNGHandler(wxPNGHandlerPtr): + def __init__(self) : + self.this = imagec.new_wxPNGHandler() + self.thisown = 1 + + + + +class wxJPEGHandlerPtr(wxImageHandlerPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __repr__(self): + return "" +class wxJPEGHandler(wxJPEGHandlerPtr): + def __init__(self) : + self.this = imagec.new_wxJPEGHandler() + self.thisown = 1 + + + + +class wxBMPHandlerPtr(wxImageHandlerPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __repr__(self): + return "" +class wxBMPHandler(wxBMPHandlerPtr): + def __init__(self) : + self.this = imagec.new_wxBMPHandler() + self.thisown = 1 + + + + +class wxGIFHandlerPtr(wxImageHandlerPtr): + def __init__(self,this): + self.this = this + self.thisown = 0 + def __repr__(self): + return "" +class wxGIFHandler(wxGIFHandlerPtr): + def __init__(self) : + self.this = imagec.new_wxGIFHandler() + self.thisown = 1 + + + + +class wxImagePtr : + def __init__(self,this): + self.this = this + self.thisown = 0 + def __del__(self): + if self.thisown == 1 : + imagec.delete_wxImage(self.this) + def ConvertToBitmap(self): + val = imagec.wxImage_ConvertToBitmap(self.this) + val = wxBitmapPtr(val) + val.thisown = 1 + return val + def Create(self,arg0,arg1): + val = imagec.wxImage_Create(self.this,arg0,arg1) + return val + def Destroy(self): + val = imagec.wxImage_Destroy(self.this) + return val + def Scale(self,arg0,arg1): + val = imagec.wxImage_Scale(self.this,arg0,arg1) + val = wxImagePtr(val) + val.thisown = 1 + return val + def SetRGB(self,arg0,arg1,arg2,arg3,arg4): + val = imagec.wxImage_SetRGB(self.this,arg0,arg1,arg2,arg3,arg4) + return val + def GetRed(self,arg0,arg1): + val = imagec.wxImage_GetRed(self.this,arg0,arg1) + return val + def GetGreen(self,arg0,arg1): + val = imagec.wxImage_GetGreen(self.this,arg0,arg1) + return val + def GetBlue(self,arg0,arg1): + val = imagec.wxImage_GetBlue(self.this,arg0,arg1) + return val + def LoadFile(self,arg0,*args): + val = apply(imagec.wxImage_LoadFile,(self.this,arg0,)+args) + return val + def LoadMimeFile(self,arg0,arg1): + val = imagec.wxImage_LoadMimeFile(self.this,arg0,arg1) + return val + def SaveFile(self,arg0,arg1): + val = imagec.wxImage_SaveFile(self.this,arg0,arg1) + return val + def SaveMimeFile(self,arg0,arg1): + val = imagec.wxImage_SaveMimeFile(self.this,arg0,arg1) + return val + def Ok(self): + val = imagec.wxImage_Ok(self.this) + return val + def GetWidth(self): + val = imagec.wxImage_GetWidth(self.this) + return val + def GetHeight(self): + val = imagec.wxImage_GetHeight(self.this) + return val + def GetData(self): + val = imagec.wxImage_GetData(self.this) + return val + def SetData(self,arg0): + val = imagec.wxImage_SetData(self.this,arg0) + return val + def SetMaskColour(self,arg0,arg1,arg2): + val = imagec.wxImage_SetMaskColour(self.this,arg0,arg1,arg2) + return val + def GetMaskRed(self): + val = imagec.wxImage_GetMaskRed(self.this) + return val + def GetMaskGreen(self): + val = imagec.wxImage_GetMaskGreen(self.this) + return val + def GetMaskBlue(self): + val = imagec.wxImage_GetMaskBlue(self.this) + return val + def SetMask(self,*args): + val = apply(imagec.wxImage_SetMask,(self.this,)+args) + return val + def HasMask(self): + val = imagec.wxImage_HasMask(self.this) + return val + def __repr__(self): + return "" +class wxImage(wxImagePtr): + def __init__(self,arg0,*args) : + self.this = apply(imagec.new_wxImage,(arg0,)+args) + self.thisown = 1 + + + + + + +#-------------- FUNCTION WRAPPERS ------------------ + +def wxNullImage(): + val = imagec.wxNullImage() + val = wxImagePtr(val) + val.thisown = 1 + return val + +def wxEmptyImage(arg0,arg1): + val = imagec.wxEmptyImage(arg0,arg1) + val = wxImagePtr(val) + val.thisown = 1 + return val + +def wxImageFromMime(arg0,arg1): + val = imagec.wxImageFromMime(arg0,arg1) + val = wxImagePtr(val) + val.thisown = 1 + return val + +def wxImageFromBitmap(arg0): + val = imagec.wxImageFromBitmap(arg0.this) + val = wxImagePtr(val) + val.thisown = 1 + return val + +def wxImage_AddHandler(arg0): + val = imagec.wxImage_AddHandler(arg0.this) + return val + + + +#-------------- VARIABLE WRAPPERS ------------------ + diff --git a/utils/wxPython/src/msw/mdi.cpp b/utils/wxPython/src/msw/mdi.cpp index 15f6f1c872..3bd74f15cc 100644 --- a/utils/wxPython/src/msw/mdi.cpp +++ b/utils/wxPython/src/msw/mdi.cpp @@ -168,7 +168,7 @@ static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -182,8 +182,12 @@ static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -207,8 +211,12 @@ static PyObject *_wrap_wxMDIParentFrame_ActivateNext(PyObject *self, PyObject *a return NULL; } } - wxMDIParentFrame_ActivateNext(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIParentFrame_ActivateNext(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -228,8 +236,12 @@ static PyObject *_wrap_wxMDIParentFrame_ActivatePrevious(PyObject *self, PyObjec return NULL; } } - wxMDIParentFrame_ActivatePrevious(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIParentFrame_ActivatePrevious(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -249,8 +261,12 @@ static PyObject *_wrap_wxMDIParentFrame_ArrangeIcons(PyObject *self, PyObject *a return NULL; } } - wxMDIParentFrame_ArrangeIcons(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIParentFrame_ArrangeIcons(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -270,8 +286,12 @@ static PyObject *_wrap_wxMDIParentFrame_Cascade(PyObject *self, PyObject *args) return NULL; } } - wxMDIParentFrame_Cascade(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIParentFrame_Cascade(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -293,8 +313,12 @@ static PyObject *_wrap_wxMDIParentFrame_GetActiveChild(PyObject *self, PyObject return NULL; } } - _result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -316,8 +340,12 @@ static PyObject *_wrap_wxMDIParentFrame_GetClientWindow(PyObject *self, PyObject return NULL; } } - _result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -339,8 +367,12 @@ static PyObject *_wrap_wxMDIParentFrame_GetToolBar(PyObject *self, PyObject *arg return NULL; } } - _result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -368,8 +400,12 @@ static PyObject *_wrap_wxMDIParentFrame_SetToolBar(PyObject *self, PyObject *arg return NULL; } } - wxMDIParentFrame_SetToolBar(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIParentFrame_SetToolBar(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -389,8 +425,12 @@ static PyObject *_wrap_wxMDIParentFrame_Tile(PyObject *self, PyObject *args) { return NULL; } } - wxMDIParentFrame_Tile(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIParentFrame_Tile(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -450,7 +490,7 @@ static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -464,8 +504,12 @@ static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -489,8 +533,12 @@ static PyObject *_wrap_wxMDIChildFrame_Activate(PyObject *self, PyObject *args) return NULL; } } - wxMDIChildFrame_Activate(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIChildFrame_Activate(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -510,8 +558,12 @@ static PyObject *_wrap_wxMDIChildFrame_Maximize(PyObject *self, PyObject *args) return NULL; } } - wxMDIChildFrame_Maximize(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIChildFrame_Maximize(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -531,8 +583,12 @@ static PyObject *_wrap_wxMDIChildFrame_Restore(PyObject *self, PyObject *args) { return NULL; } } - wxMDIChildFrame_Restore(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMDIChildFrame_Restore(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -571,8 +627,12 @@ static PyObject *_wrap_new_wxMDIClientWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -653,6 +713,7 @@ SWIGEXPORT(void,initmdic)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); @@ -683,6 +744,7 @@ SWIGEXPORT(void,initmdic)() { SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0); diff --git a/utils/wxPython/src/msw/misc.cpp b/utils/wxPython/src/msw/misc.cpp index e8da51992b..7e35be3d42 100644 --- a/utils/wxPython/src/msw/misc.cpp +++ b/utils/wxPython/src/msw/misc.cpp @@ -152,8 +152,12 @@ static PyObject *_wrap_wxFileSelector(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxFileSelector(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxFileSelector(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -186,7 +190,7 @@ static PyObject *_wrap_wxGetTextFromUser(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } if (_obj1) { @@ -194,7 +198,7 @@ static PyObject *_wrap_wxGetTextFromUser(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_obj2) { @@ -202,7 +206,7 @@ static PyObject *_wrap_wxGetTextFromUser(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxWindow_p")) { @@ -211,8 +215,12 @@ static PyObject *_wrap_wxGetTextFromUser(PyObject *self, PyObject *args) { } } _arg6 = (bool ) tempbool6; - _result = new wxString (wxGetTextFromUser(*_arg0,*_arg1,*_arg2,_arg3,_arg4,_arg5,_arg6)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxGetTextFromUser(*_arg0,*_arg1,*_arg2,_arg3,_arg4,_arg5,_arg6)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -260,14 +268,14 @@ static PyObject *_wrap_wxGetSingleChoice(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } { if (!PyString_Check(_obj1)) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_obj3) { @@ -284,10 +292,19 @@ static PyObject *_wrap_wxGetSingleChoice(PyObject *self, PyObject *args) { } _arg7 = (bool ) tempbool7; { - _arg2 = PyList_Size(_obj3); + if (_obj3) { + _arg2 = PyList_Size(_obj3); + } + else { + _arg2 = 0; + } } - _result = new wxString (wxGetSingleChoice(*_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxGetSingleChoice(*_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -334,14 +351,14 @@ static PyObject *_wrap_wxGetSingleChoiceIndex(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } { if (!PyString_Check(_obj1)) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_obj3) { @@ -358,10 +375,19 @@ static PyObject *_wrap_wxGetSingleChoiceIndex(PyObject *self, PyObject *args) { } _arg7 = (bool ) tempbool7; { - _arg2 = PyList_Size(_obj3); + if (_obj3) { + _arg2 = PyList_Size(_obj3); + } + else { + _arg2 = 0; + } } - _result = (int )wxGetSingleChoiceIndex(*_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGetSingleChoiceIndex(*_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj0) delete _arg0; @@ -397,7 +423,7 @@ static PyObject *_wrap_wxMessageBox(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } if (_obj1) { @@ -405,7 +431,7 @@ static PyObject *_wrap_wxMessageBox(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxWindow_p")) { @@ -413,8 +439,12 @@ static PyObject *_wrap_wxMessageBox(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxMessageBox(*_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMessageBox(*_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj0) delete _arg0; @@ -433,8 +463,12 @@ static PyObject *_wrap_wxColourDisplay(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxColourDisplay")) return NULL; - _result = (bool )wxColourDisplay(); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxColourDisplay(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -445,8 +479,12 @@ static PyObject *_wrap_wxDisplayDepth(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxDisplayDepth")) return NULL; - _result = (int )wxDisplayDepth(); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxDisplayDepth(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -464,8 +502,45 @@ static PyObject *_wrap_wxSetCursor(PyObject *self, PyObject *args) { return NULL; } } - wxSetCursor(*_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSetCursor(*_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +static PyObject *_wrap_wxNewId(PyObject *self, PyObject *args) { + PyObject * _resultobj; + long _result; + + self = self; + if(!PyArg_ParseTuple(args,":wxNewId")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxNewId(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); + return _resultobj; +} + +static PyObject *_wrap_wxRegisterId(PyObject *self, PyObject *args) { + PyObject * _resultobj; + long _arg0; + + self = self; + if(!PyArg_ParseTuple(args,"l:wxRegisterId",&_arg0)) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRegisterId(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -477,8 +552,12 @@ static PyObject *_wrap_NewId(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":NewId")) return NULL; - _result = (long )NewId(); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxNewId(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -489,8 +568,12 @@ static PyObject *_wrap_RegisterId(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"l:RegisterId",&_arg0)) return NULL; - RegisterId(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRegisterId(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -509,8 +592,12 @@ static PyObject *_wrap_wxBeginBusyCursor(PyObject *self, PyObject *args) { return NULL; } } - wxBeginBusyCursor(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBeginBusyCursor(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -521,8 +608,12 @@ static PyObject *_wrap_wxBell(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxBell")) return NULL; - wxBell(); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBell(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -543,8 +634,12 @@ static PyObject *_wrap_wxDisplaySize(PyObject *self, PyObject *args) { } if(!PyArg_ParseTuple(args,":wxDisplaySize")) return NULL; - wxDisplaySize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDisplaySize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -565,8 +660,12 @@ static PyObject *_wrap_wxEndBusyCursor(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxEndBusyCursor")) return NULL; - wxEndBusyCursor(); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEndBusyCursor(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -587,11 +686,15 @@ static PyObject *_wrap_wxExecute(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } _arg1 = (bool ) tempbool1; - _result = (long )wxExecute(*_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxExecute(*_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { if (_obj0) delete _arg0; @@ -616,7 +719,7 @@ static PyObject *_wrap_wxFindWindowByLabel(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } if (_argc1) { if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) { @@ -624,8 +727,12 @@ static PyObject *_wrap_wxFindWindowByLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)wxFindWindowByLabel(*_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxFindWindowByLabel(*_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -651,7 +758,7 @@ static PyObject *_wrap_wxFindWindowByName(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } if (_argc1) { if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) { @@ -659,8 +766,12 @@ static PyObject *_wrap_wxFindWindowByName(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)wxFindWindowByName(*_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxFindWindowByName(*_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -677,8 +788,12 @@ static PyObject *_wrap_wxGetActiveWindow(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxGetActiveWindow")) return NULL; - _result = (wxWindow *)wxGetActiveWindow(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxGetActiveWindow(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -693,8 +808,12 @@ static PyObject *_wrap_wxGetElapsedTime(PyObject *self, PyObject *args) { if(!PyArg_ParseTuple(args,"|i:wxGetElapsedTime",&tempbool0)) return NULL; _arg0 = (bool ) tempbool0; - _result = (long )wxGetElapsedTime(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxGetElapsedTime(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -705,8 +824,12 @@ static PyObject *_wrap_wxGetFreeMemory(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxGetFreeMemory")) return NULL; - _result = (long )wxGetFreeMemory(); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxGetFreeMemory(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -726,8 +849,12 @@ static PyObject *_wrap_wxGetMousePosition(PyObject *self, PyObject *args) { } if(!PyArg_ParseTuple(args,":wxGetMousePosition")) return NULL; - wxGetMousePosition(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGetMousePosition(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -749,8 +876,12 @@ static PyObject *_wrap_wxIsBusy(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxIsBusy")) return NULL; - _result = (bool )wxIsBusy(); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxIsBusy(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -761,8 +892,12 @@ static PyObject *_wrap_wxNow(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxNow")) return NULL; - _result = new wxString (wxNow()); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxNow()); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -786,10 +921,14 @@ static PyObject *_wrap_wxShell(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (bool )wxShell(*_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxShell(*_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj0) delete _arg0; @@ -803,8 +942,12 @@ static PyObject *_wrap_wxStartTimer(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxStartTimer")) return NULL; - wxStartTimer(); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStartTimer(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -826,8 +969,12 @@ static PyObject *_wrap_wxGetOsVersion(PyObject *self, PyObject *args) { } if(!PyArg_ParseTuple(args,":wxGetOsVersion")) return NULL; - _result = (int )wxGetOsVersion(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGetOsVersion(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { PyObject *o; o = PyInt_FromLong((long) (*_arg0)); @@ -848,8 +995,28 @@ static PyObject *_wrap_wxYield(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxYield")) return NULL; - _result = (bool )wxYield(); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxYield(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +static PyObject *_wrap_wxSafeYield(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + + self = self; + if(!PyArg_ParseTuple(args,":wxSafeYield")) + return NULL; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxSafeYield(); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -863,8 +1030,12 @@ static PyObject *_wrap_wxGetResource(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"ss|s:wxGetResource",&_arg0,&_arg1,&_arg2)) return NULL; - _result = (char *)wxGetResource(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("s", _result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (char *)wxGetResource(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("s", _result); return _resultobj; } @@ -877,8 +1048,12 @@ static PyObject *_wrap_wxResourceAddIdentifier(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"si:wxResourceAddIdentifier",&_arg0,&_arg1)) return NULL; - _result = (bool )wxResourceAddIdentifier(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxResourceAddIdentifier(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -888,8 +1063,12 @@ static PyObject *_wrap_wxResourceClear(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxResourceClear")) return NULL; - wxResourceClear(); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxResourceClear(); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -903,8 +1082,12 @@ static PyObject *_wrap_wxResourceCreateBitmap(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"s:wxResourceCreateBitmap",&_arg0)) return NULL; - _result = new wxBitmap (wxResourceCreateBitmap(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxBitmap (wxResourceCreateBitmap(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -918,8 +1101,12 @@ static PyObject *_wrap_wxResourceCreateIcon(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"s:wxResourceCreateIcon",&_arg0)) return NULL; - _result = new wxIcon (wxResourceCreateIcon(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxIcon_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxIcon (wxResourceCreateIcon(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxIcon_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -933,8 +1120,12 @@ static PyObject *_wrap_wxResourceCreateMenuBar(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"s:wxResourceCreateMenuBar",&_arg0)) return NULL; - _result = (wxMenuBar *)wxResourceCreateMenuBar(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenuBar *)wxResourceCreateMenuBar(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -947,8 +1138,12 @@ static PyObject *_wrap_wxResourceGetIdentifier(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"s:wxResourceGetIdentifier",&_arg0)) return NULL; - _result = (int )wxResourceGetIdentifier(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxResourceGetIdentifier(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -968,8 +1163,12 @@ static PyObject *_wrap_wxResourceParseData(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxResourceParseData(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxResourceParseData(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -989,8 +1188,12 @@ static PyObject *_wrap_wxResourceParseFile(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxResourceParseFile(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxResourceParseFile(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1010,8 +1213,12 @@ static PyObject *_wrap_wxResourceParseString(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxResourceParseString(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxResourceParseString(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1024,8 +1231,12 @@ static PyObject *_wrap_wxToolTip_Enable(PyObject *self, PyObject *args) { if(!PyArg_ParseTuple(args,"i:wxToolTip_Enable",&tempbool0)) return NULL; _arg0 = (bool ) tempbool0; - wxToolTip_Enable(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolTip_Enable(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1037,8 +1248,12 @@ static PyObject *_wrap_wxToolTip_SetDelay(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"l:wxToolTip_SetDelay",&_arg0)) return NULL; - wxToolTip_SetDelay(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolTip_SetDelay(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1060,8 +1275,12 @@ static PyObject *_wrap_wxSize_x_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxSize_x_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxSize_x_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1081,8 +1300,12 @@ static PyObject *_wrap_wxSize_x_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxSize_x_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxSize_x_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1103,8 +1326,12 @@ static PyObject *_wrap_wxSize_y_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxSize_y_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxSize_y_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1124,8 +1351,12 @@ static PyObject *_wrap_wxSize_y_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxSize_y_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxSize_y_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1140,8 +1371,12 @@ static PyObject *_wrap_new_wxSize(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"|ll:new_wxSize",&_arg0,&_arg1)) return NULL; - _result = (wxSize *)new_wxSize(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSize *)new_wxSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1161,8 +1396,12 @@ static PyObject *_wrap_delete_wxSize(PyObject *self, PyObject *args) { return NULL; } } - delete_wxSize(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1184,8 +1423,12 @@ static PyObject *_wrap_wxSize_Set(PyObject *self, PyObject *args) { return NULL; } } - wxSize_Set(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSize_Set(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1206,8 +1449,12 @@ static PyObject *_wrap_wxSize_GetX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxSize_GetX(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxSize_GetX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1227,8 +1474,12 @@ static PyObject *_wrap_wxSize_GetY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxSize_GetY(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxSize_GetY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1253,8 +1504,12 @@ static PyObject *_wrap_wxSize_asTuple(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxSize_asTuple(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxSize_asTuple(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -1277,8 +1532,12 @@ static PyObject *_wrap_wxRealPoint_x_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (double )wxRealPoint_x_set(_arg0,_arg1); - _resultobj = Py_BuildValue("d",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (double )wxRealPoint_x_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("d",_result); return _resultobj; } @@ -1298,8 +1557,12 @@ static PyObject *_wrap_wxRealPoint_x_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (double )wxRealPoint_x_get(_arg0); - _resultobj = Py_BuildValue("d",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (double )wxRealPoint_x_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("d",_result); return _resultobj; } @@ -1320,8 +1583,12 @@ static PyObject *_wrap_wxRealPoint_y_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (double )wxRealPoint_y_set(_arg0,_arg1); - _resultobj = Py_BuildValue("d",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (double )wxRealPoint_y_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("d",_result); return _resultobj; } @@ -1341,8 +1608,12 @@ static PyObject *_wrap_wxRealPoint_y_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (double )wxRealPoint_y_get(_arg0); - _resultobj = Py_BuildValue("d",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (double )wxRealPoint_y_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("d",_result); return _resultobj; } @@ -1357,8 +1628,12 @@ static PyObject *_wrap_new_wxRealPoint(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"|dd:new_wxRealPoint",&_arg0,&_arg1)) return NULL; - _result = (wxRealPoint *)new_wxRealPoint(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRealPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRealPoint *)new_wxRealPoint(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRealPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1378,8 +1653,12 @@ static PyObject *_wrap_delete_wxRealPoint(PyObject *self, PyObject *args) { return NULL; } } - delete_wxRealPoint(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxRealPoint(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1401,8 +1680,12 @@ static PyObject *_wrap_wxPoint_x_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxPoint_x_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxPoint_x_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1422,8 +1705,12 @@ static PyObject *_wrap_wxPoint_x_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxPoint_x_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxPoint_x_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1444,8 +1731,12 @@ static PyObject *_wrap_wxPoint_y_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxPoint_y_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxPoint_y_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1465,8 +1756,12 @@ static PyObject *_wrap_wxPoint_y_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxPoint_y_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxPoint_y_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1481,8 +1776,12 @@ static PyObject *_wrap_new_wxPoint(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"|ll:new_wxPoint",&_arg0,&_arg1)) return NULL; - _result = (wxPoint *)new_wxPoint(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPoint *)new_wxPoint(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1502,8 +1801,12 @@ static PyObject *_wrap_delete_wxPoint(PyObject *self, PyObject *args) { return NULL; } } - delete_wxPoint(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxPoint(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1528,8 +1831,12 @@ static PyObject *_wrap_wxPoint_Set(PyObject *self, PyObject *args) { return NULL; } } - wxPoint_Set(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPoint_Set(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1555,8 +1862,12 @@ static PyObject *_wrap_wxPoint_asTuple(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxPoint_asTuple(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxPoint_asTuple(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -1575,8 +1886,12 @@ static PyObject *_wrap_new_wxRect(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"|llll:new_wxRect",&_arg0,&_arg1,&_arg2,&_arg3)) return NULL; - _result = (wxRect *)new_wxRect(_arg0,_arg1,_arg2,_arg3); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRect *)new_wxRect(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1596,8 +1911,12 @@ static PyObject *_wrap_delete_wxRect(PyObject *self, PyObject *args) { return NULL; } } - delete_wxRect(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxRect(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1618,8 +1937,12 @@ static PyObject *_wrap_wxRect_GetX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetX(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1639,8 +1962,12 @@ static PyObject *_wrap_wxRect_SetX(PyObject *self, PyObject *args) { return NULL; } } - wxRect_SetX(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRect_SetX(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1661,8 +1988,12 @@ static PyObject *_wrap_wxRect_GetY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetY(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1682,8 +2013,12 @@ static PyObject *_wrap_wxRect_SetY(PyObject *self, PyObject *args) { return NULL; } } - wxRect_SetY(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRect_SetY(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1704,8 +2039,12 @@ static PyObject *_wrap_wxRect_GetWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetWidth(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1725,8 +2064,12 @@ static PyObject *_wrap_wxRect_SetWidth(PyObject *self, PyObject *args) { return NULL; } } - wxRect_SetWidth(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRect_SetWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1747,8 +2090,12 @@ static PyObject *_wrap_wxRect_GetHeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetHeight(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1768,8 +2115,12 @@ static PyObject *_wrap_wxRect_SetHeight(PyObject *self, PyObject *args) { return NULL; } } - wxRect_SetHeight(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRect_SetHeight(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1791,8 +2142,12 @@ static PyObject *_wrap_wxRect_GetPosition(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxPoint (wxRect_GetPosition(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxRect_GetPosition(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1814,8 +2169,12 @@ static PyObject *_wrap_wxRect_GetSize(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxSize (wxRect_GetSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxRect_GetSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1836,8 +2195,12 @@ static PyObject *_wrap_wxRect_GetLeft(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetLeft(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetLeft(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1857,8 +2220,12 @@ static PyObject *_wrap_wxRect_GetTop(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetTop(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetTop(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1878,8 +2245,12 @@ static PyObject *_wrap_wxRect_GetBottom(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetBottom(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetBottom(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1899,8 +2270,12 @@ static PyObject *_wrap_wxRect_GetRight(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_GetRight(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_GetRight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1921,8 +2296,12 @@ static PyObject *_wrap_wxRect_x_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_x_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_x_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1942,8 +2321,12 @@ static PyObject *_wrap_wxRect_x_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_x_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_x_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1964,8 +2347,12 @@ static PyObject *_wrap_wxRect_y_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_y_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_y_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1985,8 +2372,12 @@ static PyObject *_wrap_wxRect_y_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_y_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_y_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -2007,8 +2398,12 @@ static PyObject *_wrap_wxRect_width_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_width_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_width_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -2028,8 +2423,12 @@ static PyObject *_wrap_wxRect_width_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_width_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_width_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -2050,8 +2449,12 @@ static PyObject *_wrap_wxRect_height_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_height_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_height_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -2071,8 +2474,12 @@ static PyObject *_wrap_wxRect_height_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRect_height_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRect_height_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -2099,8 +2506,12 @@ static PyObject *_wrap_wxRect_asTuple(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxRect_asTuple(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxRect_asTuple(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -2120,8 +2531,12 @@ static PyObject *_wrap_new_wxPyTimer(PyObject *self, PyObject *args) { { _arg0 = _obj0; } - _result = (wxPyTimer *)new_wxPyTimer(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyTimer_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPyTimer *)new_wxPyTimer(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyTimer_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2141,8 +2556,12 @@ static PyObject *_wrap_delete_wxPyTimer(PyObject *self, PyObject *args) { return NULL; } } - delete_wxPyTimer(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxPyTimer(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2163,8 +2582,12 @@ static PyObject *_wrap_wxPyTimer_Interval(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPyTimer_Interval(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPyTimer_Interval(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2185,8 +2608,12 @@ static PyObject *_wrap_wxPyTimer_Start(PyObject *self, PyObject *args) { return NULL; } } - wxPyTimer_Start(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyTimer_Start(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2206,8 +2633,12 @@ static PyObject *_wrap_wxPyTimer_Stop(PyObject *self, PyObject *args) { return NULL; } } - wxPyTimer_Stop(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyTimer_Stop(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2236,8 +2667,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_Above(PyObject *self, PyObje return NULL; } } - wxIndividualLayoutConstraint_Above(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_Above(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2258,8 +2693,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_Absolute(PyObject *self, PyO return NULL; } } - wxIndividualLayoutConstraint_Absolute(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_Absolute(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2279,8 +2718,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_AsIs(PyObject *self, PyObjec return NULL; } } - wxIndividualLayoutConstraint_AsIs(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_AsIs(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2309,8 +2752,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_Below(PyObject *self, PyObje return NULL; } } - wxIndividualLayoutConstraint_Below(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_Below(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2330,8 +2777,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_Unconstrained(PyObject *self return NULL; } } - wxIndividualLayoutConstraint_Unconstrained(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_Unconstrained(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2360,8 +2811,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_LeftOf(PyObject *self, PyObj return NULL; } } - wxIndividualLayoutConstraint_LeftOf(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_LeftOf(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2391,8 +2846,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_PercentOf(PyObject *self, Py return NULL; } } - wxIndividualLayoutConstraint_PercentOf(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_PercentOf(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2421,8 +2880,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_RightOf(PyObject *self, PyOb return NULL; } } - wxIndividualLayoutConstraint_RightOf(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_RightOf(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2452,8 +2915,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_SameAs(PyObject *self, PyObj return NULL; } } - wxIndividualLayoutConstraint_SameAs(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_SameAs(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2485,8 +2952,12 @@ static PyObject *_wrap_wxIndividualLayoutConstraint_Set(PyObject *self, PyObject return NULL; } } - wxIndividualLayoutConstraint_Set(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxIndividualLayoutConstraint_Set(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2500,8 +2971,12 @@ static PyObject *_wrap_new_wxLayoutConstraints(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxLayoutConstraints")) return NULL; - _result = (wxLayoutConstraints *)new_wxLayoutConstraints(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxLayoutConstraints_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLayoutConstraints *)new_wxLayoutConstraints(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxLayoutConstraints_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2523,8 +2998,12 @@ static PyObject *_wrap_wxLayoutConstraints_bottom_get(PyObject *self, PyObject * return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_bottom_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_bottom_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2546,8 +3025,12 @@ static PyObject *_wrap_wxLayoutConstraints_centreX_get(PyObject *self, PyObject return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_centreX_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_centreX_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2569,8 +3052,12 @@ static PyObject *_wrap_wxLayoutConstraints_centreY_get(PyObject *self, PyObject return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_centreY_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_centreY_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2592,8 +3079,12 @@ static PyObject *_wrap_wxLayoutConstraints_height_get(PyObject *self, PyObject * return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_height_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_height_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2615,8 +3106,12 @@ static PyObject *_wrap_wxLayoutConstraints_left_get(PyObject *self, PyObject *ar return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_left_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_left_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2638,8 +3133,12 @@ static PyObject *_wrap_wxLayoutConstraints_right_get(PyObject *self, PyObject *a return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_right_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_right_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2661,8 +3160,12 @@ static PyObject *_wrap_wxLayoutConstraints_top_get(PyObject *self, PyObject *arg return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_top_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_top_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2684,8 +3187,12 @@ static PyObject *_wrap_wxLayoutConstraints_width_get(PyObject *self, PyObject *a return NULL; } } - _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_width_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxIndividualLayoutConstraint *)wxLayoutConstraints_width_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxIndividualLayoutConstraint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2699,8 +3206,12 @@ static PyObject *_wrap_new_wxRegion(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxRegion")) return NULL; - _result = (wxRegion *)new_wxRegion(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRegion_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRegion *)new_wxRegion(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRegion_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2720,8 +3231,12 @@ static PyObject *_wrap_delete_wxRegion(PyObject *self, PyObject *args) { return NULL; } } - delete_wxRegion(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxRegion(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2741,8 +3256,12 @@ static PyObject *_wrap_wxRegion_Clear(PyObject *self, PyObject *args) { return NULL; } } - wxRegion_Clear(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRegion_Clear(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2765,8 +3284,12 @@ static PyObject *_wrap_wxRegion_Contains(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxRegionContain )wxRegion_Contains(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRegionContain )wxRegion_Contains(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2794,8 +3317,12 @@ static PyObject *_wrap_wxRegion_ContainsPoint(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxRegionContain )wxRegion_ContainsPoint(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRegionContain )wxRegion_ContainsPoint(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2823,8 +3350,12 @@ static PyObject *_wrap_wxRegion_ContainsRect(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxRegionContain )wxRegion_ContainsRect(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRegionContain )wxRegion_ContainsRect(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2845,8 +3376,12 @@ static PyObject *_wrap_wxRegion_GetBox(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxRect (wxRegion_GetBox(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxRect (wxRegion_GetBox(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2875,8 +3410,12 @@ static PyObject *_wrap_wxRegion_Intersect(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxRegion_Intersect(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxRegion_Intersect(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2896,8 +3435,12 @@ static PyObject *_wrap_wxRegion_IsEmpty(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxRegion_IsEmpty(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxRegion_IsEmpty(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2925,8 +3468,12 @@ static PyObject *_wrap_wxRegion_Subtract(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxRegion_Subtract(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxRegion_Subtract(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2954,8 +3501,12 @@ static PyObject *_wrap_wxRegion_Union(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxRegion_Union(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxRegion_Union(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2983,8 +3534,12 @@ static PyObject *_wrap_wxRegion_Xor(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxRegion_Xor(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxRegion_Xor(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3005,8 +3560,12 @@ static PyObject *_wrap_new_wxRegionIterator(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxRegionIterator *)new_wxRegionIterator(*_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRegionIterator_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRegionIterator *)new_wxRegionIterator(*_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRegionIterator_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3026,8 +3585,12 @@ static PyObject *_wrap_delete_wxRegionIterator(PyObject *self, PyObject *args) { return NULL; } } - delete_wxRegionIterator(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxRegionIterator(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3048,8 +3611,12 @@ static PyObject *_wrap_wxRegionIterator_GetX(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRegionIterator_GetX(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRegionIterator_GetX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3069,8 +3636,12 @@ static PyObject *_wrap_wxRegionIterator_GetY(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRegionIterator_GetY(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRegionIterator_GetY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3090,8 +3661,12 @@ static PyObject *_wrap_wxRegionIterator_GetW(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRegionIterator_GetW(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRegionIterator_GetW(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3111,8 +3686,12 @@ static PyObject *_wrap_wxRegionIterator_GetWidth(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxRegionIterator_GetWidth(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRegionIterator_GetWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3132,8 +3711,12 @@ static PyObject *_wrap_wxRegionIterator_GetH(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxRegionIterator_GetH(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRegionIterator_GetH(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3153,8 +3736,12 @@ static PyObject *_wrap_wxRegionIterator_GetHeight(PyObject *self, PyObject *args return NULL; } } - _result = (long )wxRegionIterator_GetHeight(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxRegionIterator_GetHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -3175,8 +3762,12 @@ static PyObject *_wrap_wxRegionIterator_GetRect(PyObject *self, PyObject *args) return NULL; } } - _result = new wxRect (wxRegionIterator_GetRect(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxRect (wxRegionIterator_GetRect(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3197,8 +3788,12 @@ static PyObject *_wrap_wxRegionIterator_HaveRects(PyObject *self, PyObject *args return NULL; } } - _result = (bool )wxRegionIterator_HaveRects(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxRegionIterator_HaveRects(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3217,8 +3812,12 @@ static PyObject *_wrap_wxRegionIterator_Reset(PyObject *self, PyObject *args) { return NULL; } } - wxRegionIterator_Reset(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRegionIterator_Reset(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3240,8 +3839,12 @@ static PyObject *_wrap_wxRegionIterator_Next(PyObject *self, PyObject *args) { return NULL; } } - wxRegionIterator_Next(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxRegionIterator_Next(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3258,8 +3861,12 @@ static PyObject *_wrap_new_wxAcceleratorEntry(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"|iii:new_wxAcceleratorEntry",&_arg0,&_arg1,&_arg2)) return NULL; - _result = (wxAcceleratorEntry *)new_wxAcceleratorEntry(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxAcceleratorEntry_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxAcceleratorEntry *)new_wxAcceleratorEntry(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxAcceleratorEntry_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3282,8 +3889,12 @@ static PyObject *_wrap_wxAcceleratorEntry_Set(PyObject *self, PyObject *args) { return NULL; } } - wxAcceleratorEntry_Set(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxAcceleratorEntry_Set(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3304,8 +3915,12 @@ static PyObject *_wrap_wxAcceleratorEntry_GetFlags(PyObject *self, PyObject *arg return NULL; } } - _result = (int )wxAcceleratorEntry_GetFlags(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxAcceleratorEntry_GetFlags(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3325,8 +3940,12 @@ static PyObject *_wrap_wxAcceleratorEntry_GetKeyCode(PyObject *self, PyObject *a return NULL; } } - _result = (int )wxAcceleratorEntry_GetKeyCode(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxAcceleratorEntry_GetKeyCode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3346,8 +3965,12 @@ static PyObject *_wrap_wxAcceleratorEntry_GetCommand(PyObject *self, PyObject *a return NULL; } } - _result = (int )wxAcceleratorEntry_GetCommand(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxAcceleratorEntry_GetCommand(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3371,10 +3994,19 @@ static PyObject *_wrap_new_wxAcceleratorTable(PyObject *self, PyObject *args) { } } { - _arg0 = PyList_Size(_obj1); + if (_obj1) { + _arg0 = PyList_Size(_obj1); + } + else { + _arg0 = 0; + } } - _result = (wxAcceleratorTable *)new_wxAcceleratorTable(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxAcceleratorTable_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxAcceleratorTable *)new_wxAcceleratorTable(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxAcceleratorTable_p"); _resultobj = Py_BuildValue("s",_ptemp); { delete [] _arg1; @@ -3398,10 +4030,14 @@ static PyObject *_wrap_new_wxToolTip(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (wxToolTip *)new_wxToolTip(*_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolTip *)new_wxToolTip(*_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -3432,10 +4068,14 @@ static PyObject *_wrap_wxToolTip_SetTip(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxToolTip_SetTip(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolTip_SetTip(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -3460,8 +4100,12 @@ static PyObject *_wrap_wxToolTip_GetTip(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxToolTip_GetTip(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxToolTip_GetTip(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -3487,8 +4131,12 @@ static PyObject *_wrap_wxToolTip_GetWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)wxToolTip_GetWindow(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxToolTip_GetWindow(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3619,6 +4267,7 @@ static PyMethodDef misccMethods[] = { { "wxResourceClear", _wrap_wxResourceClear, 1 }, { "wxResourceAddIdentifier", _wrap_wxResourceAddIdentifier, 1 }, { "wxGetResource", _wrap_wxGetResource, 1 }, + { "wxSafeYield", _wrap_wxSafeYield, 1 }, { "wxYield", _wrap_wxYield, 1 }, { "wxGetOsVersion", _wrap_wxGetOsVersion, 1 }, { "wxStartTimer", _wrap_wxStartTimer, 1 }, @@ -3638,6 +4287,8 @@ static PyMethodDef misccMethods[] = { { "wxBeginBusyCursor", _wrap_wxBeginBusyCursor, 1 }, { "RegisterId", _wrap_RegisterId, 1 }, { "NewId", _wrap_NewId, 1 }, + { "wxRegisterId", _wrap_wxRegisterId, 1 }, + { "wxNewId", _wrap_wxNewId, 1 }, { "wxSetCursor", _wrap_wxSetCursor, 1 }, { "wxDisplayDepth", _wrap_wxDisplayDepth, 1 }, { "wxColourDisplay", _wrap_wxColourDisplay, 1 }, diff --git a/utils/wxPython/src/msw/misc.py b/utils/wxPython/src/msw/misc.py index fe8777e384..76cf76348a 100644 --- a/utils/wxPython/src/msw/misc.py +++ b/utils/wxPython/src/msw/misc.py @@ -564,6 +564,10 @@ def wxSetCursor(arg0): val = miscc.wxSetCursor(arg0.this) return val +wxNewId = miscc.wxNewId + +wxRegisterId = miscc.wxRegisterId + NewId = miscc.NewId RegisterId = miscc.RegisterId @@ -625,6 +629,8 @@ wxGetOsVersion = miscc.wxGetOsVersion wxYield = miscc.wxYield +wxSafeYield = miscc.wxSafeYield + wxGetResource = miscc.wxGetResource wxResourceAddIdentifier = miscc.wxResourceAddIdentifier diff --git a/utils/wxPython/src/msw/stattool.cpp b/utils/wxPython/src/msw/stattool.cpp index f9703b4661..ff8fd6c6ae 100644 --- a/utils/wxPython/src/msw/stattool.cpp +++ b/utils/wxPython/src/msw/stattool.cpp @@ -139,7 +139,7 @@ static PyObject *_wrap_new_wxStatusBar(PyObject *self, PyObject *args) { wxWindowID _arg1; wxPoint * _arg2 = &wxPyDefaultPosition; wxSize * _arg3 = &wxPyDefaultSize; - long _arg4 = wxST_SIZEGRIP; + long _arg4 = (wxST_SIZEGRIP); char * _arg5 = "statusBar"; char * _argc0 = 0; char * _argc2 = 0; @@ -167,8 +167,12 @@ static PyObject *_wrap_new_wxStatusBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxStatusBar *)new_wxStatusBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxStatusBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxStatusBar *)new_wxStatusBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxStatusBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -195,8 +199,12 @@ static PyObject *_wrap_wxStatusBar_GetFieldRect(PyObject *self, PyObject *args) return NULL; } } - _result = (wxRect *)wxStatusBar_GetFieldRect(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxRect *)wxStatusBar_GetFieldRect(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -217,8 +225,12 @@ static PyObject *_wrap_wxStatusBar_GetFieldsCount(PyObject *self, PyObject *args return NULL; } } - _result = (int )wxStatusBar_GetFieldsCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxStatusBar_GetFieldsCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -239,8 +251,12 @@ static PyObject *_wrap_wxStatusBar_GetStatusText(PyObject *self, PyObject *args) return NULL; } } - _result = new wxString (wxStatusBar_GetStatusText(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxStatusBar_GetStatusText(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -273,8 +289,12 @@ static PyObject *_wrap_wxStatusBar_DrawField(PyObject *self, PyObject *args) { return NULL; } } - wxStatusBar_DrawField(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStatusBar_DrawField(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -303,8 +323,12 @@ static PyObject *_wrap_wxStatusBar_DrawFieldText(PyObject *self, PyObject *args) return NULL; } } - wxStatusBar_DrawFieldText(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStatusBar_DrawFieldText(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -324,8 +348,12 @@ static PyObject *_wrap_wxStatusBar_InitColours(PyObject *self, PyObject *args) { return NULL; } } - wxStatusBar_InitColours(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStatusBar_InitColours(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -346,8 +374,12 @@ static PyObject *_wrap_wxStatusBar_SetFieldsCount(PyObject *self, PyObject *args return NULL; } } - wxStatusBar_SetFieldsCount(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStatusBar_SetFieldsCount(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -375,10 +407,14 @@ static PyObject *_wrap_wxStatusBar_SetStatusText(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxStatusBar_SetStatusText(_arg0,*_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStatusBar_SetStatusText(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -413,10 +449,19 @@ static PyObject *_wrap_wxStatusBar_SetStatusWidths(PyObject *self, PyObject *arg } } { - _arg1 = PyList_Size(_obj2); + if (_obj2) { + _arg1 = PyList_Size(_obj2); + } + else { + _arg1 = 0; + } } - wxStatusBar_SetStatusWidths(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxStatusBar_SetStatusWidths(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { delete [] _arg2; @@ -433,8 +478,12 @@ static PyObject *_wrap_new_wxToolBarTool(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxToolBarTool")) return NULL; - _result = (wxToolBarTool *)new_wxToolBarTool(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolBarTool *)new_wxToolBarTool(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -454,8 +503,12 @@ static PyObject *_wrap_delete_wxToolBarTool(PyObject *self, PyObject *args) { return NULL; } } - delete_wxToolBarTool(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxToolBarTool(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -477,8 +530,12 @@ static PyObject *_wrap_wxToolBarTool_SetSize(PyObject *self, PyObject *args) { return NULL; } } - wxToolBarTool_SetSize(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBarTool_SetSize(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -499,8 +556,12 @@ static PyObject *_wrap_wxToolBarTool_GetWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxToolBarTool_GetWidth(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_GetWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -520,8 +581,12 @@ static PyObject *_wrap_wxToolBarTool_GetHeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxToolBarTool_GetHeight(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_GetHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -542,8 +607,12 @@ static PyObject *_wrap_wxToolBarTool_m_toolStyle_set(PyObject *self, PyObject *a return NULL; } } - _result = (int )wxToolBarTool_m_toolStyle_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxToolBarTool_m_toolStyle_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -563,8 +632,12 @@ static PyObject *_wrap_wxToolBarTool_m_toolStyle_get(PyObject *self, PyObject *a return NULL; } } - _result = (int )wxToolBarTool_m_toolStyle_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxToolBarTool_m_toolStyle_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -593,8 +666,12 @@ static PyObject *_wrap_wxToolBarTool_m_clientData_set(PyObject *self, PyObject * return NULL; } } - _result = (wxObject *)wxToolBarTool_m_clientData_set(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxObject_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxObject *)wxToolBarTool_m_clientData_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxObject_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -616,8 +693,12 @@ static PyObject *_wrap_wxToolBarTool_m_clientData_get(PyObject *self, PyObject * return NULL; } } - _result = (wxObject *)wxToolBarTool_m_clientData_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxObject_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxObject *)wxToolBarTool_m_clientData_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxObject_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -639,8 +720,12 @@ static PyObject *_wrap_wxToolBarTool_m_index_set(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxToolBarTool_m_index_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxToolBarTool_m_index_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -660,8 +745,12 @@ static PyObject *_wrap_wxToolBarTool_m_index_get(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxToolBarTool_m_index_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxToolBarTool_m_index_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -682,8 +771,12 @@ static PyObject *_wrap_wxToolBarTool_m_x_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxToolBarTool_m_x_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_x_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -703,8 +796,12 @@ static PyObject *_wrap_wxToolBarTool_m_x_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxToolBarTool_m_x_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_x_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -725,8 +822,12 @@ static PyObject *_wrap_wxToolBarTool_m_y_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxToolBarTool_m_y_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_y_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -746,8 +847,12 @@ static PyObject *_wrap_wxToolBarTool_m_y_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (long )wxToolBarTool_m_y_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_y_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -768,8 +873,12 @@ static PyObject *_wrap_wxToolBarTool_m_width_set(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxToolBarTool_m_width_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_width_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -789,8 +898,12 @@ static PyObject *_wrap_wxToolBarTool_m_width_get(PyObject *self, PyObject *args) return NULL; } } - _result = (long )wxToolBarTool_m_width_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_width_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -811,8 +924,12 @@ static PyObject *_wrap_wxToolBarTool_m_height_set(PyObject *self, PyObject *args return NULL; } } - _result = (long )wxToolBarTool_m_height_set(_arg0,_arg1); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_height_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -832,8 +949,12 @@ static PyObject *_wrap_wxToolBarTool_m_height_get(PyObject *self, PyObject *args return NULL; } } - _result = (long )wxToolBarTool_m_height_get(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxToolBarTool_m_height_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -856,8 +977,12 @@ static PyObject *_wrap_wxToolBarTool_m_toggleState_set(PyObject *self, PyObject } } _arg1 = (bool ) tempbool1; - _result = (bool )wxToolBarTool_m_toggleState_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_toggleState_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -877,8 +1002,12 @@ static PyObject *_wrap_wxToolBarTool_m_toggleState_get(PyObject *self, PyObject return NULL; } } - _result = (bool )wxToolBarTool_m_toggleState_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_toggleState_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -901,8 +1030,12 @@ static PyObject *_wrap_wxToolBarTool_m_isToggle_set(PyObject *self, PyObject *ar } } _arg1 = (bool ) tempbool1; - _result = (bool )wxToolBarTool_m_isToggle_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_isToggle_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -922,8 +1055,12 @@ static PyObject *_wrap_wxToolBarTool_m_isToggle_get(PyObject *self, PyObject *ar return NULL; } } - _result = (bool )wxToolBarTool_m_isToggle_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_isToggle_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -946,8 +1083,12 @@ static PyObject *_wrap_wxToolBarTool_m_deleteSecondBitmap_set(PyObject *self, Py } } _arg1 = (bool ) tempbool1; - _result = (bool )wxToolBarTool_m_deleteSecondBitmap_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_deleteSecondBitmap_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -967,8 +1108,12 @@ static PyObject *_wrap_wxToolBarTool_m_deleteSecondBitmap_get(PyObject *self, Py return NULL; } } - _result = (bool )wxToolBarTool_m_deleteSecondBitmap_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_deleteSecondBitmap_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -991,8 +1136,12 @@ static PyObject *_wrap_wxToolBarTool_m_enabled_set(PyObject *self, PyObject *arg } } _arg1 = (bool ) tempbool1; - _result = (bool )wxToolBarTool_m_enabled_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_enabled_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1012,8 +1161,12 @@ static PyObject *_wrap_wxToolBarTool_m_enabled_get(PyObject *self, PyObject *arg return NULL; } } - _result = (bool )wxToolBarTool_m_enabled_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_enabled_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1042,8 +1195,12 @@ static PyObject *_wrap_wxToolBarTool_m_bitmap1_set(PyObject *self, PyObject *arg return NULL; } } - _result = (wxBitmap *)wxToolBarTool_m_bitmap1_set(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxToolBarTool_m_bitmap1_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1065,8 +1222,12 @@ static PyObject *_wrap_wxToolBarTool_m_bitmap1_get(PyObject *self, PyObject *arg return NULL; } } - _result = (wxBitmap *)wxToolBarTool_m_bitmap1_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxToolBarTool_m_bitmap1_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1096,8 +1257,12 @@ static PyObject *_wrap_wxToolBarTool_m_bitmap2_set(PyObject *self, PyObject *arg return NULL; } } - _result = (wxBitmap *)wxToolBarTool_m_bitmap2_set(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxToolBarTool_m_bitmap2_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1119,8 +1284,12 @@ static PyObject *_wrap_wxToolBarTool_m_bitmap2_get(PyObject *self, PyObject *arg return NULL; } } - _result = (wxBitmap *)wxToolBarTool_m_bitmap2_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxToolBarTool_m_bitmap2_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1144,8 +1313,12 @@ static PyObject *_wrap_wxToolBarTool_m_isMenuCommand_set(PyObject *self, PyObjec } } _arg1 = (bool ) tempbool1; - _result = (bool )wxToolBarTool_m_isMenuCommand_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_isMenuCommand_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1165,8 +1338,12 @@ static PyObject *_wrap_wxToolBarTool_m_isMenuCommand_get(PyObject *self, PyObjec return NULL; } } - _result = (bool )wxToolBarTool_m_isMenuCommand_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBarTool_m_isMenuCommand_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1193,10 +1370,14 @@ static PyObject *_wrap_wxToolBarTool_m_shortHelpString_set(PyObject *self, PyObj PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (wxString *)wxToolBarTool_m_shortHelpString_set(_arg0,_arg1); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxString *)wxToolBarTool_m_shortHelpString_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } { @@ -1222,8 +1403,12 @@ static PyObject *_wrap_wxToolBarTool_m_shortHelpString_get(PyObject *self, PyObj return NULL; } } - _result = (wxString *)wxToolBarTool_m_shortHelpString_get(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxString *)wxToolBarTool_m_shortHelpString_get(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } return _resultobj; @@ -1252,10 +1437,14 @@ static PyObject *_wrap_wxToolBarTool_m_longHelpString_set(PyObject *self, PyObje PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (wxString *)wxToolBarTool_m_longHelpString_set(_arg0,_arg1); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxString *)wxToolBarTool_m_longHelpString_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } { @@ -1281,8 +1470,12 @@ static PyObject *_wrap_wxToolBarTool_m_longHelpString_get(PyObject *self, PyObje return NULL; } } - _result = (wxString *)wxToolBarTool_m_longHelpString_get(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxString *)wxToolBarTool_m_longHelpString_get(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } return _resultobj; @@ -1348,8 +1541,12 @@ static PyObject *_wrap_new_wxToolBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxToolBar *)new_wxToolBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolBar *)new_wxToolBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1369,8 +1566,12 @@ static PyObject *_wrap_wxToolBar_AddSeparator(PyObject *self, PyObject *args) { return NULL; } } - wxToolBar_AddSeparator(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_AddSeparator(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1426,7 +1627,7 @@ static PyObject *_wrap_wxToolBar_AddTool(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg7 = new wxString(PyString_AsString(_obj7)); + _arg7 = new wxString(PyString_AsString(_obj7), PyString_Size(_obj7)); } if (_obj8) { @@ -1434,10 +1635,14 @@ static PyObject *_wrap_wxToolBar_AddTool(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg8 = new wxString(PyString_AsString(_obj8)); + _arg8 = new wxString(PyString_AsString(_obj8), PyString_Size(_obj8)); } - _result = (wxToolBarTool *)wxToolBar_AddTool(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7,*_arg8); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolBarTool *)wxToolBar_AddTool(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7,*_arg8); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj7) @@ -1490,7 +1695,7 @@ static PyObject *_wrap_wxToolBar_AddSimpleTool(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg3 = new wxString(PyString_AsString(_obj3)); + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); } if (_obj4) { @@ -1498,10 +1703,14 @@ static PyObject *_wrap_wxToolBar_AddSimpleTool(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg4 = new wxString(PyString_AsString(_obj4)); + _arg4 = new wxString(PyString_AsString(_obj4), PyString_Size(_obj4)); } - _result = (wxToolBarTool *)wxToolBar_AddSimpleTool(_arg0,_arg1,*_arg2,*_arg3,*_arg4); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolBarTool *)wxToolBar_AddSimpleTool(_arg0,_arg1,*_arg2,*_arg3,*_arg4); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj3) @@ -1533,8 +1742,12 @@ static PyObject *_wrap_wxToolBar_EnableTool(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxToolBar_EnableTool(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_EnableTool(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1558,8 +1771,12 @@ static PyObject *_wrap_wxToolBar_FindToolForPosition(PyObject *self, PyObject *a return NULL; } } - _result = (wxToolBarTool *)wxToolBar_FindToolForPosition(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolBarTool *)wxToolBar_FindToolForPosition(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolBarTool_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1581,8 +1798,12 @@ static PyObject *_wrap_wxToolBar_GetToolSize(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxSize (wxToolBar_GetToolSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxToolBar_GetToolSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1604,8 +1825,12 @@ static PyObject *_wrap_wxToolBar_GetToolBitmapSize(PyObject *self, PyObject *arg return NULL; } } - _result = new wxSize (wxToolBar_GetToolBitmapSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxToolBar_GetToolBitmapSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1633,8 +1858,12 @@ static PyObject *_wrap_wxToolBar_SetToolBitmapSize(PyObject *self, PyObject *arg return NULL; } } - wxToolBar_SetToolBitmapSize(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_SetToolBitmapSize(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1656,8 +1885,12 @@ static PyObject *_wrap_wxToolBar_GetMaxSize(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxSize (wxToolBar_GetMaxSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxToolBar_GetMaxSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1679,8 +1912,12 @@ static PyObject *_wrap_wxToolBar_GetToolEnabled(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxToolBar_GetToolEnabled(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBar_GetToolEnabled(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1701,8 +1938,12 @@ static PyObject *_wrap_wxToolBar_GetToolLongHelp(PyObject *self, PyObject *args) return NULL; } } - _result = new wxString (wxToolBar_GetToolLongHelp(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxToolBar_GetToolLongHelp(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1727,8 +1968,12 @@ static PyObject *_wrap_wxToolBar_GetToolPacking(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxToolBar_GetToolPacking(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxToolBar_GetToolPacking(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1748,8 +1993,12 @@ static PyObject *_wrap_wxToolBar_GetToolSeparation(PyObject *self, PyObject *arg return NULL; } } - _result = (int )wxToolBar_GetToolSeparation(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxToolBar_GetToolSeparation(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1770,8 +2019,12 @@ static PyObject *_wrap_wxToolBar_GetToolShortHelp(PyObject *self, PyObject *args return NULL; } } - _result = new wxString (wxToolBar_GetToolShortHelp(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxToolBar_GetToolShortHelp(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1797,8 +2050,12 @@ static PyObject *_wrap_wxToolBar_GetToolState(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxToolBar_GetToolState(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBar_GetToolState(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1818,8 +2075,12 @@ static PyObject *_wrap_wxToolBar_Realize(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxToolBar_Realize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxToolBar_Realize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1846,10 +2107,14 @@ static PyObject *_wrap_wxToolBar_SetToolLongHelp(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxToolBar_SetToolLongHelp(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_SetToolLongHelp(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -1881,10 +2146,14 @@ static PyObject *_wrap_wxToolBar_SetToolShortHelp(PyObject *self, PyObject *args PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxToolBar_SetToolShortHelp(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_SetToolShortHelp(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -1916,8 +2185,12 @@ static PyObject *_wrap_wxToolBar_SetMargins(PyObject *self, PyObject *args) { return NULL; } } - wxToolBar_SetMargins(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_SetMargins(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1938,8 +2211,12 @@ static PyObject *_wrap_wxToolBar_SetToolPacking(PyObject *self, PyObject *args) return NULL; } } - wxToolBar_SetToolPacking(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_SetToolPacking(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1960,8 +2237,12 @@ static PyObject *_wrap_wxToolBar_SetToolSeparation(PyObject *self, PyObject *arg return NULL; } } - wxToolBar_SetToolSeparation(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_SetToolSeparation(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1985,8 +2266,12 @@ static PyObject *_wrap_wxToolBar_ToggleTool(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxToolBar_ToggleTool(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxToolBar_ToggleTool(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2120,6 +2405,7 @@ SWIGEXPORT(void,initstattoolc)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); @@ -2149,6 +2435,7 @@ SWIGEXPORT(void,initstattoolc)() { SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0); diff --git a/utils/wxPython/src/msw/utils.cpp b/utils/wxPython/src/msw/utils.cpp index 83754c47ec..4f60365a5c 100644 --- a/utils/wxPython/src/msw/utils.cpp +++ b/utils/wxPython/src/msw/utils.cpp @@ -152,7 +152,7 @@ static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } if (_obj1) { @@ -160,7 +160,7 @@ static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_obj2) { @@ -168,7 +168,7 @@ static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_obj3) { @@ -176,10 +176,14 @@ static PyObject *_wrap_new_wxConfig(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg3 = new wxString(PyString_AsString(_obj3)); + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); } - _result = (wxConfig *)new_wxConfig(*_arg0,*_arg1,*_arg2,*_arg3,_arg4); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxConfig_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxConfig *)new_wxConfig(*_arg0,*_arg1,*_arg2,*_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxConfig_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -215,8 +219,12 @@ static PyObject *_wrap_delete_wxConfig(PyObject *self, PyObject *args) { return NULL; } } - delete_wxConfig(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxConfig(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -236,8 +244,12 @@ static PyObject *_wrap_wxConfig_DontCreateOnDemand(PyObject *self, PyObject *arg return NULL; } } - wxConfig_DontCreateOnDemand(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxConfig_DontCreateOnDemand(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -258,8 +270,12 @@ static PyObject *_wrap_wxConfig_DeleteAll(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxConfig_DeleteAll(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_DeleteAll(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -288,11 +304,15 @@ static PyObject *_wrap_wxConfig_DeleteEntry(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } _arg2 = (bool ) tempbool2; - _result = (bool )wxConfig_DeleteEntry(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_DeleteEntry(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -323,10 +343,14 @@ static PyObject *_wrap_wxConfig_DeleteGroup(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxConfig_DeleteGroup(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_DeleteGroup(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -357,10 +381,14 @@ static PyObject *_wrap_wxConfig_Exists(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxConfig_Exists(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_Exists(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -387,8 +415,12 @@ static PyObject *_wrap_wxConfig_Flush(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - _result = (bool )wxConfig_Flush(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_Flush(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -408,8 +440,12 @@ static PyObject *_wrap_wxConfig_GetAppName(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxConfig_GetAppName(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxConfig_GetAppName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -441,8 +477,12 @@ static PyObject *_wrap_wxConfig_GetFirstGroup(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxConfig_GetFirstGroup(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxConfig_GetFirstGroup(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -471,8 +511,12 @@ static PyObject *_wrap_wxConfig_GetFirstEntry(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxConfig_GetFirstEntry(_arg0); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxConfig_GetFirstEntry(_arg0); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -501,8 +545,12 @@ static PyObject *_wrap_wxConfig_GetNextGroup(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxConfig_GetNextGroup(_arg0,_arg1); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxConfig_GetNextGroup(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -531,8 +579,12 @@ static PyObject *_wrap_wxConfig_GetNextEntry(PyObject *self, PyObject *args) { return NULL; } } - _result = (PyObject *)wxConfig_GetNextEntry(_arg0,_arg1); { + wxPy_BEGIN_ALLOW_THREADS; + _result = (PyObject *)wxConfig_GetNextEntry(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = _result; } return _resultobj; @@ -557,8 +609,12 @@ static PyObject *_wrap_wxConfig_GetNumberOfEntries(PyObject *self, PyObject *arg } } _arg1 = (bool ) tempbool1; - _result = (int )wxConfig_GetNumberOfEntries(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxConfig_GetNumberOfEntries(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -581,8 +637,12 @@ static PyObject *_wrap_wxConfig_GetNumberOfGroups(PyObject *self, PyObject *args } } _arg1 = (bool ) tempbool1; - _result = (int )wxConfig_GetNumberOfGroups(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxConfig_GetNumberOfGroups(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -602,8 +662,12 @@ static PyObject *_wrap_wxConfig_GetPath(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxConfig_GetPath(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxConfig_GetPath(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -628,8 +692,12 @@ static PyObject *_wrap_wxConfig_GetVendorName(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxConfig_GetVendorName(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxConfig_GetVendorName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -661,10 +729,14 @@ static PyObject *_wrap_wxConfig_HasEntry(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxConfig_HasEntry(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_HasEntry(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -695,10 +767,14 @@ static PyObject *_wrap_wxConfig_HasGroup(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxConfig_HasGroup(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_HasGroup(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -722,8 +798,12 @@ static PyObject *_wrap_wxConfig_IsExpandingEnvVars(PyObject *self, PyObject *arg return NULL; } } - _result = (bool )wxConfig_IsExpandingEnvVars(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_IsExpandingEnvVars(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -743,8 +823,12 @@ static PyObject *_wrap_wxConfig_IsRecordingDefaults(PyObject *self, PyObject *ar return NULL; } } - _result = (bool )wxConfig_IsRecordingDefaults(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_IsRecordingDefaults(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -773,7 +857,7 @@ static PyObject *_wrap_wxConfig_Read(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_obj2) { @@ -781,10 +865,14 @@ static PyObject *_wrap_wxConfig_Read(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _result = new wxString (wxConfig_Read(_arg0,*_arg1,*_arg2)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxConfig_Read(_arg0,*_arg1,*_arg2)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -825,10 +913,14 @@ static PyObject *_wrap_wxConfig_ReadInt(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (long )wxConfig_ReadInt(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxConfig_ReadInt(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); { if (_obj1) delete _arg1; @@ -860,44 +952,14 @@ static PyObject *_wrap_wxConfig_ReadFloat(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (double )wxConfig_ReadFloat(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("d",_result); { - if (_obj1) - delete _arg1; -} - return _resultobj; -} + wxPy_BEGIN_ALLOW_THREADS; + _result = (double )wxConfig_ReadFloat(_arg0,*_arg1,_arg2); -#define wxConfig_SetAppName(_swigobj,_swigarg0) (_swigobj->SetAppName(_swigarg0)) -static PyObject *_wrap_wxConfig_SetAppName(PyObject *self, PyObject *args) { - PyObject * _resultobj; - wxConfig * _arg0; - wxString * _arg1; - char * _argc0 = 0; - PyObject * _obj1 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"sO:wxConfig_SetAppName",&_argc0,&_obj1)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_SetAppName. Expected _wxConfig_p."); - return NULL; - } - } -{ - if (!PyString_Check(_obj1)) { - PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); - return NULL; - } - _arg1 = new wxString(PyString_AsString(_obj1)); -} - wxConfig_SetAppName(_arg0,*_arg1); - Py_INCREF(Py_None); - _resultobj = Py_None; + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("d",_result); { if (_obj1) delete _arg1; @@ -923,8 +985,12 @@ static PyObject *_wrap_wxConfig_SetExpandEnvVars(PyObject *self, PyObject *args) } } _arg1 = (bool ) tempbool1; - wxConfig_SetExpandEnvVars(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxConfig_SetExpandEnvVars(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -951,10 +1017,14 @@ static PyObject *_wrap_wxConfig_SetPath(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxConfig_SetPath(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxConfig_SetPath(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -981,43 +1051,13 @@ static PyObject *_wrap_wxConfig_SetRecordDefaults(PyObject *self, PyObject *args } } _arg1 = (bool ) tempbool1; - wxConfig_SetRecordDefaults(_arg0,_arg1); - Py_INCREF(Py_None); - _resultobj = Py_None; - return _resultobj; -} - -#define wxConfig_SetVendorName(_swigobj,_swigarg0) (_swigobj->SetVendorName(_swigarg0)) -static PyObject *_wrap_wxConfig_SetVendorName(PyObject *self, PyObject *args) { - PyObject * _resultobj; - wxConfig * _arg0; - wxString * _arg1; - char * _argc0 = 0; - PyObject * _obj1 = 0; - - self = self; - if(!PyArg_ParseTuple(args,"sO:wxConfig_SetVendorName",&_argc0,&_obj1)) - return NULL; - if (_argc0) { - if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxConfig_p")) { - PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxConfig_SetVendorName. Expected _wxConfig_p."); - return NULL; - } - } { - if (!PyString_Check(_obj1)) { - PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); - return NULL; - } - _arg1 = new wxString(PyString_AsString(_obj1)); -} - wxConfig_SetVendorName(_arg0,*_arg1); - Py_INCREF(Py_None); + wxPy_BEGIN_ALLOW_THREADS; + wxConfig_SetRecordDefaults(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; -{ - if (_obj1) - delete _arg1; -} return _resultobj; } @@ -1046,17 +1086,21 @@ static PyObject *_wrap_wxConfig_Write(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } { if (!PyString_Check(_obj2)) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _result = (bool )wxConfig_Write(_arg0,*_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_Write(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -1092,10 +1136,14 @@ static PyObject *_wrap_wxConfig_WriteInt(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxConfig_WriteInt(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_WriteInt(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -1127,10 +1175,14 @@ static PyObject *_wrap_wxConfig_WriteFloat(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (bool )wxConfig_WriteFloat(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxConfig_WriteFloat(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -1142,11 +1194,9 @@ static PyMethodDef utilscMethods[] = { { "wxConfig_WriteFloat", _wrap_wxConfig_WriteFloat, 1 }, { "wxConfig_WriteInt", _wrap_wxConfig_WriteInt, 1 }, { "wxConfig_Write", _wrap_wxConfig_Write, 1 }, - { "wxConfig_SetVendorName", _wrap_wxConfig_SetVendorName, 1 }, { "wxConfig_SetRecordDefaults", _wrap_wxConfig_SetRecordDefaults, 1 }, { "wxConfig_SetPath", _wrap_wxConfig_SetPath, 1 }, { "wxConfig_SetExpandEnvVars", _wrap_wxConfig_SetExpandEnvVars, 1 }, - { "wxConfig_SetAppName", _wrap_wxConfig_SetAppName, 1 }, { "wxConfig_ReadFloat", _wrap_wxConfig_ReadFloat, 1 }, { "wxConfig_ReadInt", _wrap_wxConfig_ReadInt, 1 }, { "wxConfig_Read", _wrap_wxConfig_Read, 1 }, diff --git a/utils/wxPython/src/msw/utils.py b/utils/wxPython/src/msw/utils.py index c37f637d95..321e6ed069 100644 --- a/utils/wxPython/src/msw/utils.py +++ b/utils/wxPython/src/msw/utils.py @@ -73,9 +73,6 @@ class wxConfigPtr : def ReadFloat(self,arg0,*args): val = apply(utilsc.wxConfig_ReadFloat,(self.this,arg0,)+args) return val - def SetAppName(self,arg0): - val = utilsc.wxConfig_SetAppName(self.this,arg0) - return val def SetExpandEnvVars(self,*args): val = apply(utilsc.wxConfig_SetExpandEnvVars,(self.this,)+args) return val @@ -85,9 +82,6 @@ class wxConfigPtr : def SetRecordDefaults(self,*args): val = apply(utilsc.wxConfig_SetRecordDefaults,(self.this,)+args) return val - def SetVendorName(self,arg0): - val = utilsc.wxConfig_SetVendorName(self.this,arg0) - return val def Write(self,arg0,arg1): val = utilsc.wxConfig_Write(self.this,arg0,arg1) return val diff --git a/utils/wxPython/src/msw/windows.cpp b/utils/wxPython/src/msw/windows.cpp index 1a8fb00437..e4ca7301a8 100644 --- a/utils/wxPython/src/msw/windows.cpp +++ b/utils/wxPython/src/msw/windows.cpp @@ -133,8 +133,12 @@ static PyObject *_wrap_wxWindow_FindFocus(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":wxWindow_FindFocus")) return NULL; - _result = (wxWindow *)wxWindow_FindFocus(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxWindow_FindFocus(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -148,12 +152,49 @@ static PyObject *_wrap_wxWindow_FromHWND(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,"l:wxWindow_FromHWND",&_arg0)) return NULL; - _result = (wxWindow *)wxWindow_FromHWND(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxWindow_FromHWND(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } +#define wxEvtHandler_ProcessEvent(_swigobj,_swigarg0) (_swigobj->ProcessEvent(_swigarg0)) +static PyObject *_wrap_wxEvtHandler_ProcessEvent(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxEvtHandler * _arg0; + wxEvent * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxEvtHandler_ProcessEvent",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxEvtHandler_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_ProcessEvent. Expected _wxEvtHandler_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxEvent_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxEvtHandler_ProcessEvent. Expected _wxEvent_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxEvtHandler_ProcessEvent(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject * func) { if (PyCallable_Check(func)) { self->Connect(id, lastId, eventType, @@ -183,8 +224,12 @@ static PyObject *_wrap_wxEvtHandler_Connect(PyObject *self, PyObject *args) { { _arg4 = _obj4; } - wxEvtHandler_Connect(_arg0,_arg1,_arg2,_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxEvtHandler_Connect(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -233,8 +278,12 @@ static PyObject *_wrap_new_wxWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)new_wxWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)new_wxWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -254,8 +303,12 @@ static PyObject *_wrap_wxWindow_CaptureMouse(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_CaptureMouse(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_CaptureMouse(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -276,8 +329,12 @@ static PyObject *_wrap_wxWindow_Center(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Center(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Center(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -298,8 +355,12 @@ static PyObject *_wrap_wxWindow_Centre(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Centre(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Centre(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -333,8 +394,12 @@ static PyObject *_wrap_wxWindow_ClientToScreenXY(PyObject *self, PyObject *args) temp0 = (int) PyInt_AsLong(_obj2); _arg2 = &temp0; } - wxWindow_ClientToScreenXY(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_ClientToScreenXY(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -374,8 +439,12 @@ static PyObject *_wrap_wxWindow_ClientToScreen(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxPoint (wxWindow_ClientToScreen(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxWindow_ClientToScreen(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -397,8 +466,12 @@ static PyObject *_wrap_wxWindow_Close(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxWindow_Close(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_Close(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -418,8 +491,12 @@ static PyObject *_wrap_wxWindow_Destroy(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxWindow_Destroy(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_Destroy(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -438,8 +515,12 @@ static PyObject *_wrap_wxWindow_DestroyChildren(PyObject *self, PyObject *args) return NULL; } } - wxWindow_DestroyChildren(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_DestroyChildren(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -462,8 +543,12 @@ static PyObject *_wrap_wxWindow_DragAcceptFiles(PyObject *self, PyObject *args) } } _arg1 = (bool ) tempbool1; - wxWindow_DragAcceptFiles(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_DragAcceptFiles(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -486,8 +571,12 @@ static PyObject *_wrap_wxWindow_Enable(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxWindow_Enable(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Enable(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -510,8 +599,12 @@ static PyObject *_wrap_wxWindow_FindWindowById(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)wxWindow_FindWindowById(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxWindow_FindWindowById(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -540,10 +633,14 @@ static PyObject *_wrap_wxWindow_FindWindowByName(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (wxWindow *)wxWindow_FindWindowByName(_arg0,*_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxWindow_FindWindowByName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj1) @@ -567,8 +664,12 @@ static PyObject *_wrap_wxWindow_Fit(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Fit(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Fit(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -590,8 +691,12 @@ static PyObject *_wrap_wxWindow_GetBackgroundColour(PyObject *self, PyObject *ar return NULL; } } - _result = new wxColour (wxWindow_GetBackgroundColour(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxColour (wxWindow_GetBackgroundColour(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -612,8 +717,12 @@ static PyObject *_wrap_wxWindow_GetCharHeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxWindow_GetCharHeight(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxWindow_GetCharHeight(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -633,8 +742,12 @@ static PyObject *_wrap_wxWindow_GetCharWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxWindow_GetCharWidth(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxWindow_GetCharWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -663,8 +776,12 @@ static PyObject *_wrap_wxWindow_GetClientSizeTuple(PyObject *self, PyObject *arg return NULL; } } - wxWindow_GetClientSizeTuple(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_GetClientSizeTuple(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -696,8 +813,12 @@ static PyObject *_wrap_wxWindow_GetClientSize(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxSize (wxWindow_GetClientSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxWindow_GetClientSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -719,8 +840,12 @@ static PyObject *_wrap_wxWindow_GetConstraints(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxLayoutConstraints *)wxWindow_GetConstraints(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxLayoutConstraints_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLayoutConstraints *)wxWindow_GetConstraints(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxLayoutConstraints_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -742,8 +867,12 @@ static PyObject *_wrap_wxWindow_GetDefaultItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxButton *)wxWindow_GetDefaultItem(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxButton_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxButton *)wxWindow_GetDefaultItem(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxButton_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -765,9 +894,13 @@ static PyObject *_wrap_wxWindow_GetFont(PyObject *self, PyObject *args) { return NULL; } } - wxFont & _result_ref = wxWindow_GetFont(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont & _result_ref = wxWindow_GetFont(_arg0); _result = (wxFont *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -789,8 +922,12 @@ static PyObject *_wrap_wxWindow_GetForegroundColour(PyObject *self, PyObject *ar return NULL; } } - _result = new wxColour (wxWindow_GetForegroundColour(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxColour (wxWindow_GetForegroundColour(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -812,8 +949,12 @@ static PyObject *_wrap_wxWindow_GetGrandParent(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)wxWindow_GetGrandParent(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxWindow_GetGrandParent(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -834,8 +975,12 @@ static PyObject *_wrap_wxWindow_GetId(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxWindow_GetId(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxWindow_GetId(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -855,8 +1000,12 @@ static PyObject *_wrap_wxWindow_GetLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxWindow_GetLabel(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxWindow_GetLabel(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -881,8 +1030,12 @@ static PyObject *_wrap_wxWindow_GetName(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxWindow_GetName(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxWindow_GetName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -908,8 +1061,12 @@ static PyObject *_wrap_wxWindow_GetParent(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)wxWindow_GetParent(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxWindow_GetParent(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -939,8 +1096,12 @@ static PyObject *_wrap_wxWindow_GetPositionTuple(PyObject *self, PyObject *args) return NULL; } } - wxWindow_GetPositionTuple(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_GetPositionTuple(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -972,8 +1133,12 @@ static PyObject *_wrap_wxWindow_GetPosition(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxPoint (wxWindow_GetPosition(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxWindow_GetPosition(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -995,8 +1160,12 @@ static PyObject *_wrap_wxWindow_GetRect(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxRect (wxWindow_GetRect(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxRect (wxWindow_GetRect(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1017,8 +1186,12 @@ static PyObject *_wrap_wxWindow_GetReturnCode(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxWindow_GetReturnCode(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxWindow_GetReturnCode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1039,8 +1212,12 @@ static PyObject *_wrap_wxWindow_GetScrollThumb(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxWindow_GetScrollThumb(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxWindow_GetScrollThumb(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1061,8 +1238,12 @@ static PyObject *_wrap_wxWindow_GetScrollPos(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxWindow_GetScrollPos(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxWindow_GetScrollPos(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1083,8 +1264,12 @@ static PyObject *_wrap_wxWindow_GetScrollRange(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxWindow_GetScrollRange(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxWindow_GetScrollRange(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1113,8 +1298,12 @@ static PyObject *_wrap_wxWindow_GetSizeTuple(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_GetSizeTuple(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_GetSizeTuple(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -1146,8 +1335,12 @@ static PyObject *_wrap_wxWindow_GetSize(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxSize (wxWindow_GetSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxWindow_GetSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1184,10 +1377,14 @@ static PyObject *_wrap_wxWindow_GetTextExtent(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxWindow_GetTextExtent(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_GetTextExtent(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -1250,7 +1447,7 @@ static PyObject *_wrap_wxWindow_GetFullTextExtent(PyObject *self, PyObject *args PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } if (_argc6) { if (SWIG_GetPtr(_argc6,(void **) &_arg6,"_wxFont_p")) { @@ -1258,8 +1455,12 @@ static PyObject *_wrap_wxWindow_GetFullTextExtent(PyObject *self, PyObject *args return NULL; } } - wxWindow_GetFullTextExtent(_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_GetFullTextExtent(_arg0,*_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -1304,8 +1505,12 @@ static PyObject *_wrap_wxWindow_GetTitle(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxWindow_GetTitle(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxWindow_GetTitle(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -1330,8 +1535,12 @@ static PyObject *_wrap_wxWindow_GetWindowStyleFlag(PyObject *self, PyObject *arg return NULL; } } - _result = (long )wxWindow_GetWindowStyleFlag(_arg0); - _resultobj = Py_BuildValue("l",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (long )wxWindow_GetWindowStyleFlag(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("l",_result); return _resultobj; } @@ -1350,8 +1559,12 @@ static PyObject *_wrap_wxWindow_InitDialog(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_InitDialog(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_InitDialog(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1372,8 +1585,12 @@ static PyObject *_wrap_wxWindow_IsEnabled(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxWindow_IsEnabled(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_IsEnabled(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1393,8 +1610,12 @@ static PyObject *_wrap_wxWindow_IsRetained(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxWindow_IsRetained(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_IsRetained(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1414,8 +1635,12 @@ static PyObject *_wrap_wxWindow_IsShown(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxWindow_IsShown(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_IsShown(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1434,8 +1659,12 @@ static PyObject *_wrap_wxWindow_Layout(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Layout(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Layout(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1473,7 +1702,7 @@ static PyObject *_wrap_wxWindow_LoadFromResource(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxResourceTable_p")) { @@ -1481,8 +1710,12 @@ static PyObject *_wrap_wxWindow_LoadFromResource(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxWindow_LoadFromResource(_arg0,_arg1,*_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_LoadFromResource(_arg0,_arg1,*_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj2) delete _arg2; @@ -1505,8 +1738,12 @@ static PyObject *_wrap_wxWindow_Lower(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Lower(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Lower(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1529,8 +1766,12 @@ static PyObject *_wrap_wxWindow_MakeModal(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxWindow_MakeModal(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_MakeModal(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1552,8 +1793,12 @@ static PyObject *_wrap_wxWindow_MoveXY(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_MoveXY(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_MoveXY(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1581,8 +1826,12 @@ static PyObject *_wrap_wxWindow_Move(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Move(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Move(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1613,8 +1862,12 @@ static PyObject *_wrap_wxWindow_PopupMenu(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxWindow_PopupMenu(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_PopupMenu(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1633,8 +1886,12 @@ static PyObject *_wrap_wxWindow_Raise(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Raise(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Raise(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1665,8 +1922,12 @@ static PyObject *_wrap_wxWindow_Refresh(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_Refresh(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_Refresh(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1686,8 +1947,12 @@ static PyObject *_wrap_wxWindow_ReleaseMouse(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_ReleaseMouse(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_ReleaseMouse(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1721,8 +1986,12 @@ static PyObject *_wrap_wxWindow_ScreenToClientXY(PyObject *self, PyObject *args) temp0 = (int) PyInt_AsLong(_obj2); _arg2 = &temp0; } - wxWindow_ScreenToClientXY(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_ScreenToClientXY(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -1762,8 +2031,12 @@ static PyObject *_wrap_wxWindow_ScreenToClient(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxPoint (wxWindow_ScreenToClient(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxWindow_ScreenToClient(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1793,8 +2066,12 @@ static PyObject *_wrap_wxWindow_ScrollWindow(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_ScrollWindow(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_ScrollWindow(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1822,8 +2099,12 @@ static PyObject *_wrap_wxWindow_SetAcceleratorTable(PyObject *self, PyObject *ar return NULL; } } - wxWindow_SetAcceleratorTable(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetAcceleratorTable(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1846,8 +2127,12 @@ static PyObject *_wrap_wxWindow_SetAutoLayout(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxWindow_SetAutoLayout(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetAutoLayout(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1875,8 +2160,12 @@ static PyObject *_wrap_wxWindow_SetBackgroundColour(PyObject *self, PyObject *ar return NULL; } } - wxWindow_SetBackgroundColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetBackgroundColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1904,8 +2193,12 @@ static PyObject *_wrap_wxWindow_SetConstraints(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetConstraints(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetConstraints(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1928,8 +2221,12 @@ static PyObject *_wrap_wxWindow_SetDoubleClick(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxWindow_SetDoubleClick(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetDoubleClick(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1949,8 +2246,12 @@ static PyObject *_wrap_wxWindow_SetFocus(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetFocus(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetFocus(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1978,8 +2279,12 @@ static PyObject *_wrap_wxWindow_SetFont(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetFont(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2007,8 +2312,12 @@ static PyObject *_wrap_wxWindow_SetForegroundColour(PyObject *self, PyObject *ar return NULL; } } - wxWindow_SetForegroundColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetForegroundColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2029,8 +2338,12 @@ static PyObject *_wrap_wxWindow_SetId(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetId(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetId(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2057,10 +2370,14 @@ static PyObject *_wrap_wxWindow_SetName(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxWindow_SetName(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -2085,8 +2402,12 @@ static PyObject *_wrap_wxWindow_SetReturnCode(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetReturnCode(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetReturnCode(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2113,8 +2434,12 @@ static PyObject *_wrap_wxWindow_SetScrollbar(PyObject *self, PyObject *args) { } } _arg5 = (bool ) tempbool5; - wxWindow_SetScrollbar(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetScrollbar(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2139,8 +2464,12 @@ static PyObject *_wrap_wxWindow_SetScrollPos(PyObject *self, PyObject *args) { } } _arg3 = (bool ) tempbool3; - wxWindow_SetScrollPos(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetScrollPos(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2165,8 +2494,12 @@ static PyObject *_wrap_wxWindow_SetDimensions(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetDimensions(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetDimensions(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2196,8 +2529,12 @@ static PyObject *_wrap_wxWindow_SetSize(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetSize(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetSize(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2227,8 +2564,12 @@ static PyObject *_wrap_wxWindow_SetPosition(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetPosition(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetPosition(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2254,8 +2595,12 @@ static PyObject *_wrap_wxWindow_SetSizeHints(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetSizeHints(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetSizeHints(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2277,8 +2622,12 @@ static PyObject *_wrap_wxWindow_SetClientSizeWH(PyObject *self, PyObject *args) return NULL; } } - wxWindow_SetClientSizeWH(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetClientSizeWH(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2306,8 +2655,12 @@ static PyObject *_wrap_wxWindow_SetClientSize(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetClientSize(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetClientSize(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2335,8 +2688,12 @@ static PyObject *_wrap_wxWindow_SetCursor(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetCursor(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetCursor(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2363,10 +2720,14 @@ static PyObject *_wrap_wxWindow_SetTitle(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxWindow_SetTitle(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetTitle(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -2394,8 +2755,12 @@ static PyObject *_wrap_wxWindow_Show(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - _result = (bool )wxWindow_Show(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_Show(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2415,8 +2780,12 @@ static PyObject *_wrap_wxWindow_TransferDataFromWindow(PyObject *self, PyObject return NULL; } } - _result = (bool )wxWindow_TransferDataFromWindow(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_TransferDataFromWindow(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2436,8 +2805,12 @@ static PyObject *_wrap_wxWindow_TransferDataToWindow(PyObject *self, PyObject *a return NULL; } } - _result = (bool )wxWindow_TransferDataToWindow(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_TransferDataToWindow(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2457,8 +2830,12 @@ static PyObject *_wrap_wxWindow_Validate(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxWindow_Validate(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxWindow_Validate(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2479,8 +2856,12 @@ static PyObject *_wrap_wxWindow_WarpPointer(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_WarpPointer(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_WarpPointer(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2510,8 +2891,12 @@ static PyObject *_wrap_wxWindow_ConvertDialogPointToPixels(PyObject *self, PyObj return NULL; } } - _result = new wxPoint (wxWindow_ConvertDialogPointToPixels(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxWindow_ConvertDialogPointToPixels(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2541,8 +2926,12 @@ static PyObject *_wrap_wxWindow_ConvertDialogSizeToPixels(PyObject *self, PyObje return NULL; } } - _result = new wxSize (wxWindow_ConvertDialogSizeToPixels(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxWindow_ConvertDialogSizeToPixels(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2572,8 +2961,12 @@ static PyObject *_wrap_wxWindow_ConvertPixelPointToDialog(PyObject *self, PyObje return NULL; } } - _result = new wxPoint (wxWindow_ConvertPixelPointToDialog(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxPoint (wxWindow_ConvertPixelPointToDialog(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2603,8 +2996,12 @@ static PyObject *_wrap_wxWindow_ConvertPixelSizeToDialog(PyObject *self, PyObjec return NULL; } } - _result = new wxSize (wxWindow_ConvertPixelSizeToDialog(_arg0,*_arg1)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxWindow_ConvertPixelSizeToDialog(_arg0,*_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2631,10 +3028,14 @@ static PyObject *_wrap_wxWindow_SetToolTipString(PyObject *self, PyObject *args) PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxWindow_SetToolTipString(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetToolTipString(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -2666,8 +3067,12 @@ static PyObject *_wrap_wxWindow_SetToolTip(PyObject *self, PyObject *args) { return NULL; } } - wxWindow_SetToolTip(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxWindow_SetToolTip(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2689,8 +3094,12 @@ static PyObject *_wrap_wxWindow_GetToolTip(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxToolTip *)wxWindow_GetToolTip(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxToolTip *)wxWindow_GetToolTip(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2747,8 +3156,12 @@ static PyObject *_wrap_new_wxPanel(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxPanel *)new_wxPanel(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPanel_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPanel *)new_wxPanel(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPanel_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2768,8 +3181,12 @@ static PyObject *_wrap_wxPanel_InitDialog(PyObject *self, PyObject *args) { return NULL; } } - wxPanel_InitDialog(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPanel_InitDialog(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2829,7 +3246,7 @@ static PyObject *_wrap_new_wxDialog(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) { @@ -2843,8 +3260,12 @@ static PyObject *_wrap_new_wxDialog(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxDialog *)new_wxDialog(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxDialog_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxDialog *)new_wxDialog(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxDialog_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj2) @@ -2869,8 +3290,12 @@ static PyObject *_wrap_wxDialog_Centre(PyObject *self, PyObject *args) { return NULL; } } - wxDialog_Centre(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDialog_Centre(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2891,8 +3316,12 @@ static PyObject *_wrap_wxDialog_EndModal(PyObject *self, PyObject *args) { return NULL; } } - wxDialog_EndModal(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDialog_EndModal(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2913,8 +3342,12 @@ static PyObject *_wrap_wxDialog_GetTitle(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxDialog_GetTitle(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxDialog_GetTitle(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -2941,8 +3374,12 @@ static PyObject *_wrap_wxDialog_Iconize(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxDialog_Iconize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDialog_Iconize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2963,8 +3400,12 @@ static PyObject *_wrap_wxDialog_IsIconized(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxDialog_IsIconized(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxDialog_IsIconized(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2986,8 +3427,12 @@ static PyObject *_wrap_wxDialog_SetModal(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxDialog_SetModal(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDialog_SetModal(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3008,8 +3453,12 @@ static PyObject *_wrap_wxDialog_IsModal(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxDialog_IsModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxDialog_IsModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3035,10 +3484,14 @@ static PyObject *_wrap_wxDialog_SetTitle(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxDialog_SetTitle(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxDialog_SetTitle(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -3066,8 +3519,12 @@ static PyObject *_wrap_wxDialog_Show(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - _result = (bool )wxDialog_Show(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxDialog_Show(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3087,8 +3544,12 @@ static PyObject *_wrap_wxDialog_ShowModal(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxDialog_ShowModal(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxDialog_ShowModal(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3144,8 +3605,12 @@ static PyObject *_wrap_new_wxScrolledWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxScrolledWindow *)new_wxScrolledWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrolledWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxScrolledWindow *)new_wxScrolledWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrolledWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3171,8 +3636,12 @@ static PyObject *_wrap_wxScrolledWindow_EnableScrolling(PyObject *self, PyObject } _arg1 = (bool ) tempbool1; _arg2 = (bool ) tempbool2; - wxScrolledWindow_EnableScrolling(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrolledWindow_EnableScrolling(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3202,8 +3671,12 @@ static PyObject *_wrap_wxScrolledWindow_GetScrollPixelsPerUnit(PyObject *self, P return NULL; } } - wxScrolledWindow_GetScrollPixelsPerUnit(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrolledWindow_GetScrollPixelsPerUnit(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -3243,8 +3716,12 @@ static PyObject *_wrap_wxScrolledWindow_GetVirtualSize(PyObject *self, PyObject return NULL; } } - wxScrolledWindow_GetVirtualSize(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrolledWindow_GetVirtualSize(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -3275,8 +3752,12 @@ static PyObject *_wrap_wxScrolledWindow_IsRetained(PyObject *self, PyObject *arg return NULL; } } - _result = (bool )wxScrolledWindow_IsRetained(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxScrolledWindow_IsRetained(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3303,8 +3784,12 @@ static PyObject *_wrap_wxScrolledWindow_PrepareDC(PyObject *self, PyObject *args return NULL; } } - wxScrolledWindow_PrepareDC(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrolledWindow_PrepareDC(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3326,8 +3811,12 @@ static PyObject *_wrap_wxScrolledWindow_Scroll(PyObject *self, PyObject *args) { return NULL; } } - wxScrolledWindow_Scroll(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrolledWindow_Scroll(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3353,8 +3842,12 @@ static PyObject *_wrap_wxScrolledWindow_SetScrollbars(PyObject *self, PyObject * return NULL; } } - wxScrolledWindow_SetScrollbars(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrolledWindow_SetScrollbars(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3384,8 +3877,12 @@ static PyObject *_wrap_wxScrolledWindow_ViewStart(PyObject *self, PyObject *args return NULL; } } - wxScrolledWindow_ViewStart(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxScrolledWindow_ViewStart(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { PyObject *o; @@ -3425,10 +3922,14 @@ static PyObject *_wrap_new_wxMenu(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } - _result = (wxMenu *)new_wxMenu(*_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenu_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenu *)new_wxMenu(*_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenu_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -3463,7 +3964,7 @@ static PyObject *_wrap_wxMenu_Append(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_obj3) { @@ -3471,10 +3972,14 @@ static PyObject *_wrap_wxMenu_Append(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg3 = new wxString(PyString_AsString(_obj3)); + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); } - wxMenu_Append(_arg0,_arg1,*_arg2,*_arg3,_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_Append(_arg0,_arg1,*_arg2,*_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -3514,7 +4019,7 @@ static PyObject *_wrap_wxMenu_AppendMenu(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } if (_argc3) { if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxMenu_p")) { @@ -3528,10 +4033,14 @@ static PyObject *_wrap_wxMenu_AppendMenu(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg4 = new wxString(PyString_AsString(_obj4)); + _arg4 = new wxString(PyString_AsString(_obj4), PyString_Size(_obj4)); } - wxMenu_AppendMenu(_arg0,_arg1,*_arg2,_arg3,*_arg4); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_AppendMenu(_arg0,_arg1,*_arg2,_arg3,*_arg4); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -3567,8 +4076,12 @@ static PyObject *_wrap_wxMenu_AppendItem(PyObject *self, PyObject *args) { return NULL; } } - wxMenu_AppendItem(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_AppendItem(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3588,8 +4101,12 @@ static PyObject *_wrap_wxMenu_AppendSeparator(PyObject *self, PyObject *args) { return NULL; } } - wxMenu_AppendSeparator(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_AppendSeparator(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3609,8 +4126,12 @@ static PyObject *_wrap_wxMenu_Break(PyObject *self, PyObject *args) { return NULL; } } - wxMenu_Break(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_Break(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3634,8 +4155,12 @@ static PyObject *_wrap_wxMenu_Check(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxMenu_Check(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_Check(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3659,8 +4184,12 @@ static PyObject *_wrap_wxMenu_Enable(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxMenu_Enable(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_Enable(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3688,10 +4217,14 @@ static PyObject *_wrap_wxMenu_FindItem(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - _result = (int )wxMenu_FindItem(_arg0,*_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMenu_FindItem(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -3715,8 +4248,12 @@ static PyObject *_wrap_wxMenu_GetTitle(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxMenu_GetTitle(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenu_GetTitle(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -3747,10 +4284,14 @@ static PyObject *_wrap_wxMenu_SetTitle(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxMenu_SetTitle(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_SetTitle(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -3777,8 +4318,12 @@ static PyObject *_wrap_wxMenu_FindItemForId(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMenuItem *)wxMenu_FindItemForId(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuItem_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenuItem *)wxMenu_FindItemForId(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuItem_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3800,8 +4345,12 @@ static PyObject *_wrap_wxMenu_GetHelpString(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxMenu_GetHelpString(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenu_GetHelpString(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -3827,8 +4376,12 @@ static PyObject *_wrap_wxMenu_GetLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxMenu_GetLabel(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenu_GetLabel(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -3860,10 +4413,14 @@ static PyObject *_wrap_wxMenu_SetHelpString(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxMenu_SetHelpString(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_SetHelpString(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -3889,8 +4446,12 @@ static PyObject *_wrap_wxMenu_IsChecked(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenu_IsChecked(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenu_IsChecked(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3911,8 +4472,12 @@ static PyObject *_wrap_wxMenu_IsEnabled(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenu_IsEnabled(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenu_IsEnabled(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3939,10 +4504,14 @@ static PyObject *_wrap_wxMenu_SetLabel(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxMenu_SetLabel(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenu_SetLabel(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -3986,14 +4555,18 @@ static PyObject *_wrap_new_wxPyMenu(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg0 = new wxString(PyString_AsString(_obj0)); + _arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0)); } if (_obj1) { _arg1 = _obj1; } - _result = (wxPyMenu *)new_wxPyMenu(*_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyMenu_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPyMenu *)new_wxPyMenu(*_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyMenu_p"); _resultobj = Py_BuildValue("s",_ptemp); { if (_obj0) @@ -4017,8 +4590,12 @@ static PyObject *_wrap_delete_wxPyMenu(PyObject *self, PyObject *args) { return NULL; } } - delete_wxPyMenu(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxPyMenu(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4040,8 +4617,12 @@ static PyObject *_wrap_new_wxMenuBar(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxMenuBar")) return NULL; - _result = (wxMenuBar *)new_wxMenuBar(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenuBar *)new_wxMenuBar(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4076,10 +4657,14 @@ static PyObject *_wrap_wxMenuBar_Append(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxMenuBar_Append(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuBar_Append(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -4107,8 +4692,12 @@ static PyObject *_wrap_wxMenuBar_Check(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxMenuBar_Check(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuBar_Check(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4130,8 +4719,12 @@ static PyObject *_wrap_wxMenuBar_Checked(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenuBar_Checked(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenuBar_Checked(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4154,8 +4747,12 @@ static PyObject *_wrap_wxMenuBar_Enable(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxMenuBar_Enable(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuBar_Enable(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4177,8 +4774,12 @@ static PyObject *_wrap_wxMenuBar_Enabled(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenuBar_Enabled(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenuBar_Enabled(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4207,17 +4808,21 @@ static PyObject *_wrap_wxMenuBar_FindMenuItem(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } { if (!PyString_Check(_obj2)) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _result = (int )wxMenuBar_FindMenuItem(_arg0,*_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMenuBar_FindMenuItem(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj1) delete _arg1; @@ -4247,8 +4852,12 @@ static PyObject *_wrap_wxMenuBar_FindItemForId(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMenuItem *)wxMenuBar_FindItemForId(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuItem_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenuItem *)wxMenuBar_FindItemForId(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuItem_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4272,8 +4881,12 @@ static PyObject *_wrap_wxMenuBar_EnableTop(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - wxMenuBar_EnableTop(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuBar_EnableTop(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4295,8 +4908,12 @@ static PyObject *_wrap_wxMenuBar_GetHelpString(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxMenuBar_GetHelpString(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenuBar_GetHelpString(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -4322,8 +4939,12 @@ static PyObject *_wrap_wxMenuBar_GetLabel(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxMenuBar_GetLabel(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenuBar_GetLabel(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -4355,10 +4976,14 @@ static PyObject *_wrap_wxMenuBar_SetHelpString(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxMenuBar_SetHelpString(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuBar_SetHelpString(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -4390,10 +5015,14 @@ static PyObject *_wrap_wxMenuBar_SetLabel(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxMenuBar_SetLabel(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuBar_SetLabel(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -4419,8 +5048,12 @@ static PyObject *_wrap_wxMenuBar_GetLabelTop(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxMenuBar_GetLabelTop(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenuBar_GetLabelTop(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -4452,10 +5085,14 @@ static PyObject *_wrap_wxMenuBar_SetLabelTop(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxMenuBar_SetLabelTop(_arg0,_arg1,*_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuBar_SetLabelTop(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -4480,8 +5117,12 @@ static PyObject *_wrap_wxMenuBar_GetMenuCount(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxMenuBar_GetMenuCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMenuBar_GetMenuCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4503,12 +5144,83 @@ static PyObject *_wrap_wxMenuBar_GetMenu(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMenu *)wxMenuBar_GetMenu(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenu_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenu *)wxMenuBar_GetMenu(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenu_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } +#define new_wxMenuItem(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (new wxMenuItem(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5)) +static PyObject *_wrap_new_wxMenuItem(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxMenuItem * _result; + wxMenu * _arg0 = NULL; + int _arg1 = ID_SEPARATOR; + wxString * _arg2 = &wxPyEmptyStr; + wxString * _arg3 = &wxPyEmptyStr; + bool _arg4 = (0); + wxMenu * _arg5 = NULL; + char * _argc0 = 0; + PyObject * _obj2 = 0; + PyObject * _obj3 = 0; + int tempbool4; + char * _argc5 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"|siOOis:new_wxMenuItem",&_argc0,&_arg1,&_obj2,&_obj3,&tempbool4,&_argc5)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenu_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMenuItem. Expected _wxMenu_p."); + return NULL; + } + } + if (_obj2) +{ + if (!PyString_Check(_obj2)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); +} + if (_obj3) +{ + if (!PyString_Check(_obj3)) { + PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); + return NULL; + } + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); +} + _arg4 = (bool ) tempbool4; + if (_argc5) { + if (SWIG_GetPtr(_argc5,(void **) &_arg5,"_wxMenu_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of new_wxMenuItem. Expected _wxMenu_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenuItem *)new_wxMenuItem(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenuItem_p"); + _resultobj = Py_BuildValue("s",_ptemp); +{ + if (_obj2) + delete _arg2; +} +{ + if (_obj3) + delete _arg3; +} + return _resultobj; +} + #define wxMenuItem_IsSeparator(_swigobj) (_swigobj->IsSeparator()) static PyObject *_wrap_wxMenuItem_IsSeparator(PyObject *self, PyObject *args) { PyObject * _resultobj; @@ -4525,8 +5237,12 @@ static PyObject *_wrap_wxMenuItem_IsSeparator(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenuItem_IsSeparator(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenuItem_IsSeparator(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4546,8 +5262,12 @@ static PyObject *_wrap_wxMenuItem_IsEnabled(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenuItem_IsEnabled(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenuItem_IsEnabled(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4567,8 +5287,12 @@ static PyObject *_wrap_wxMenuItem_IsChecked(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenuItem_IsChecked(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenuItem_IsChecked(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4588,8 +5312,12 @@ static PyObject *_wrap_wxMenuItem_IsCheckable(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxMenuItem_IsCheckable(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxMenuItem_IsCheckable(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4609,8 +5337,12 @@ static PyObject *_wrap_wxMenuItem_GetId(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxMenuItem_GetId(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMenuItem_GetId(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -4631,8 +5363,12 @@ static PyObject *_wrap_wxMenuItem_GetSubMenu(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxMenu *)wxMenuItem_GetSubMenu(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenu_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxMenu *)wxMenuItem_GetSubMenu(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxMenu_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -4659,10 +5395,14 @@ static PyObject *_wrap_wxMenuItem_SetName(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxMenuItem_SetName(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_SetName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -4687,10 +5427,16 @@ static PyObject *_wrap_wxMenuItem_GetName(PyObject *self, PyObject *args) { return NULL; } } - const wxString & _result_ref = wxMenuItem_GetName(_arg0); - _result = (wxString *) &_result_ref; { - _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenuItem_GetName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); +} +{ + delete _result; } return _resultobj; } @@ -4711,10 +5457,16 @@ static PyObject *_wrap_wxMenuItem_GetHelp(PyObject *self, PyObject *args) { return NULL; } } - const wxString & _result_ref = wxMenuItem_GetHelp(_arg0); - _result = (wxString *) &_result_ref; { - _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxMenuItem_GetHelp(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ + _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); +} +{ + delete _result; } return _resultobj; } @@ -4741,10 +5493,14 @@ static PyObject *_wrap_wxMenuItem_SetHelp(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxMenuItem_SetHelp(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_SetHelp(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -4771,8 +5527,12 @@ static PyObject *_wrap_wxMenuItem_Enable(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxMenuItem_Enable(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_Enable(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4795,8 +5555,317 @@ static PyObject *_wrap_wxMenuItem_Check(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxMenuItem_Check(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_Check(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxMenuItem_GetBackgroundColour(_swigobj) (_swigobj->GetBackgroundColour()) +static PyObject *_wrap_wxMenuItem_GetBackgroundColour(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxColour * _result; + wxMenuItem * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxMenuItem_GetBackgroundColour",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_GetBackgroundColour. Expected _wxMenuItem_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxMenuItem_GetBackgroundColour(_arg0); + _result = (wxColour *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxMenuItem_GetBitmap(_swigobj,_swigarg0) (_swigobj->GetBitmap(_swigarg0)) +static PyObject *_wrap_wxMenuItem_GetBitmap(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxBitmap * _result; + wxMenuItem * _arg0; + bool _arg1 = (1); + char * _argc0 = 0; + int tempbool1; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s|i:wxMenuItem_GetBitmap",&_argc0,&tempbool1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_GetBitmap. Expected _wxMenuItem_p."); + return NULL; + } + } + _arg1 = (bool ) tempbool1; +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxBitmap (wxMenuItem_GetBitmap(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxMenuItem_GetFont(_swigobj) (_swigobj->GetFont()) +static PyObject *_wrap_wxMenuItem_GetFont(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxFont * _result; + wxMenuItem * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxMenuItem_GetFont",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_GetFont. Expected _wxMenuItem_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont & _result_ref = wxMenuItem_GetFont(_arg0); + _result = (wxFont *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxMenuItem_GetMarginWidth(_swigobj) (_swigobj->GetMarginWidth()) +static PyObject *_wrap_wxMenuItem_GetMarginWidth(PyObject *self, PyObject *args) { + PyObject * _resultobj; + int _result; + wxMenuItem * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxMenuItem_GetMarginWidth",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_GetMarginWidth. Expected _wxMenuItem_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxMenuItem_GetMarginWidth(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxMenuItem_GetTextColour(_swigobj) (_swigobj->GetTextColour()) +static PyObject *_wrap_wxMenuItem_GetTextColour(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxColour * _result; + wxMenuItem * _arg0; + char * _argc0 = 0; + char _ptemp[128]; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxMenuItem_GetTextColour",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_GetTextColour. Expected _wxMenuItem_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxMenuItem_GetTextColour(_arg0); + _result = (wxColour *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + _resultobj = Py_BuildValue("s",_ptemp); + return _resultobj; +} + +#define wxMenuItem_SetBackgroundColour(_swigobj,_swigarg0) (_swigobj->SetBackgroundColour(_swigarg0)) +static PyObject *_wrap_wxMenuItem_SetBackgroundColour(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxMenuItem * _arg0; + wxColour * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxMenuItem_SetBackgroundColour",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_SetBackgroundColour. Expected _wxMenuItem_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxColour_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMenuItem_SetBackgroundColour. Expected _wxColour_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_SetBackgroundColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxMenuItem_SetBitmaps(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetBitmaps(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxMenuItem_SetBitmaps(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxMenuItem * _arg0; + wxBitmap * _arg1; + wxBitmap * _arg2 = &wxNullBitmap; + char * _argc0 = 0; + char * _argc1 = 0; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss|s:wxMenuItem_SetBitmaps",&_argc0,&_argc1,&_argc2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_SetBitmaps. Expected _wxMenuItem_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxBitmap_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMenuItem_SetBitmaps. Expected _wxBitmap_p."); + return NULL; + } + } + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_wxBitmap_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxMenuItem_SetBitmaps. Expected _wxBitmap_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_SetBitmaps(_arg0,*_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxMenuItem_SetFont(_swigobj,_swigarg0) (_swigobj->SetFont(_swigarg0)) +static PyObject *_wrap_wxMenuItem_SetFont(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxMenuItem * _arg0; + wxFont * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxMenuItem_SetFont",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_SetFont. Expected _wxMenuItem_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxFont_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMenuItem_SetFont. Expected _wxFont_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_SetFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxMenuItem_SetMarginWidth(_swigobj,_swigarg0) (_swigobj->SetMarginWidth(_swigarg0)) +static PyObject *_wrap_wxMenuItem_SetMarginWidth(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxMenuItem * _arg0; + int _arg1; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"si:wxMenuItem_SetMarginWidth",&_argc0,&_arg1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_SetMarginWidth. Expected _wxMenuItem_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_SetMarginWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + +#define wxMenuItem_SetTextColour(_swigobj,_swigarg0) (_swigobj->SetTextColour(_swigarg0)) +static PyObject *_wrap_wxMenuItem_SetTextColour(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxMenuItem * _arg0; + wxColour * _arg1; + char * _argc0 = 0; + char * _argc1 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss:wxMenuItem_SetTextColour",&_argc0,&_argc1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMenuItem_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuItem_SetTextColour. Expected _wxMenuItem_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxColour_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMenuItem_SetTextColour. Expected _wxColour_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_SetTextColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -4816,14 +5885,28 @@ static PyObject *_wrap_wxMenuItem_DeleteSubMenu(PyObject *self, PyObject *args) return NULL; } } - wxMenuItem_DeleteSubMenu(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxMenuItem_DeleteSubMenu(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } static PyMethodDef windowscMethods[] = { { "wxMenuItem_DeleteSubMenu", _wrap_wxMenuItem_DeleteSubMenu, 1 }, + { "wxMenuItem_SetTextColour", _wrap_wxMenuItem_SetTextColour, 1 }, + { "wxMenuItem_SetMarginWidth", _wrap_wxMenuItem_SetMarginWidth, 1 }, + { "wxMenuItem_SetFont", _wrap_wxMenuItem_SetFont, 1 }, + { "wxMenuItem_SetBitmaps", _wrap_wxMenuItem_SetBitmaps, 1 }, + { "wxMenuItem_SetBackgroundColour", _wrap_wxMenuItem_SetBackgroundColour, 1 }, + { "wxMenuItem_GetTextColour", _wrap_wxMenuItem_GetTextColour, 1 }, + { "wxMenuItem_GetMarginWidth", _wrap_wxMenuItem_GetMarginWidth, 1 }, + { "wxMenuItem_GetFont", _wrap_wxMenuItem_GetFont, 1 }, + { "wxMenuItem_GetBitmap", _wrap_wxMenuItem_GetBitmap, 1 }, + { "wxMenuItem_GetBackgroundColour", _wrap_wxMenuItem_GetBackgroundColour, 1 }, { "wxMenuItem_Check", _wrap_wxMenuItem_Check, 1 }, { "wxMenuItem_Enable", _wrap_wxMenuItem_Enable, 1 }, { "wxMenuItem_SetHelp", _wrap_wxMenuItem_SetHelp, 1 }, @@ -4836,6 +5919,7 @@ static PyMethodDef windowscMethods[] = { { "wxMenuItem_IsChecked", _wrap_wxMenuItem_IsChecked, 1 }, { "wxMenuItem_IsEnabled", _wrap_wxMenuItem_IsEnabled, 1 }, { "wxMenuItem_IsSeparator", _wrap_wxMenuItem_IsSeparator, 1 }, + { "new_wxMenuItem", _wrap_new_wxMenuItem, 1 }, { "wxMenuBar_GetMenu", _wrap_wxMenuBar_GetMenu, 1 }, { "wxMenuBar_GetMenuCount", _wrap_wxMenuBar_GetMenuCount, 1 }, { "wxMenuBar_SetLabelTop", _wrap_wxMenuBar_SetLabelTop, 1 }, @@ -4900,6 +5984,8 @@ static PyMethodDef windowscMethods[] = { { "wxWindow_SetToolTipString", _wrap_wxWindow_SetToolTipString, 1 }, { "wxWindow_ConvertPixelSizeToDialog", _wrap_wxWindow_ConvertPixelSizeToDialog, 1 }, { "wxWindow_ConvertPixelPointToDialog", _wrap_wxWindow_ConvertPixelPointToDialog, 1 }, + { "wxWindow_DLG_SZE", _wrap_wxWindow_ConvertDialogSizeToPixels, 1 }, + { "wxWindow_DLG_PNT", _wrap_wxWindow_ConvertDialogPointToPixels, 1 }, { "wxWindow_ConvertDialogSizeToPixels", _wrap_wxWindow_ConvertDialogSizeToPixels, 1 }, { "wxWindow_ConvertDialogPointToPixels", _wrap_wxWindow_ConvertDialogPointToPixels, 1 }, { "wxWindow_WarpPointer", _wrap_wxWindow_WarpPointer, 1 }, @@ -4987,6 +6073,7 @@ static PyMethodDef windowscMethods[] = { { "wxWindow_CaptureMouse", _wrap_wxWindow_CaptureMouse, 1 }, { "new_wxWindow", _wrap_new_wxWindow, 1 }, { "wxEvtHandler_Connect", _wrap_wxEvtHandler_Connect, 1 }, + { "wxEvtHandler_ProcessEvent", _wrap_wxEvtHandler_ProcessEvent, 1 }, { "wxWindow_FromHWND", _wrap_wxWindow_FromHWND, 1 }, { "wxWindow_FindFocus", _wrap_wxWindow_FindFocus, 1 }, { NULL, NULL } diff --git a/utils/wxPython/src/msw/windows.py b/utils/wxPython/src/msw/windows.py index 1d315ba70b..ecc37e6fb0 100644 --- a/utils/wxPython/src/msw/windows.py +++ b/utils/wxPython/src/msw/windows.py @@ -16,6 +16,9 @@ class wxEvtHandlerPtr : def __init__(self,this): self.this = this self.thisown = 0 + def ProcessEvent(self,arg0): + val = windowsc.wxEvtHandler_ProcessEvent(self.this,arg0.this) + return val def Connect(self,arg0,arg1,arg2,arg3): val = windowsc.wxEvtHandler_Connect(self.this,arg0,arg1,arg2,arg3) return val @@ -326,6 +329,16 @@ class wxWindowPtr(wxEvtHandlerPtr): val = wxSizePtr(val) val.thisown = 1 return val + def DLG_PNT(self,arg0): + val = windowsc.wxWindow_DLG_PNT(self.this,arg0.this) + val = wxPointPtr(val) + val.thisown = 1 + return val + def DLG_SZE(self,arg0): + val = windowsc.wxWindow_DLG_SZE(self.this,arg0.this) + val = wxSizePtr(val) + val.thisown = 1 + return val def ConvertPixelPointToDialog(self,arg0): val = windowsc.wxWindow_ConvertPixelPointToDialog(self.this,arg0.this) val = wxPointPtr(val) @@ -672,14 +685,60 @@ class wxMenuItemPtr : def Check(self,*args): val = apply(windowsc.wxMenuItem_Check,(self.this,)+args) return val + def GetBackgroundColour(self): + val = windowsc.wxMenuItem_GetBackgroundColour(self.this) + val = wxColourPtr(val) + return val + def GetBitmap(self,*args): + val = apply(windowsc.wxMenuItem_GetBitmap,(self.this,)+args) + val = wxBitmapPtr(val) + val.thisown = 1 + return val + def GetFont(self): + val = windowsc.wxMenuItem_GetFont(self.this) + val = wxFontPtr(val) + return val + def GetMarginWidth(self): + val = windowsc.wxMenuItem_GetMarginWidth(self.this) + return val + def GetTextColour(self): + val = windowsc.wxMenuItem_GetTextColour(self.this) + val = wxColourPtr(val) + return val + def SetBackgroundColour(self,arg0): + val = windowsc.wxMenuItem_SetBackgroundColour(self.this,arg0.this) + return val + def SetBitmaps(self,arg0,*args): + argl = map(None,args) + try: argl[0] = argl[0].this + except: pass + args = tuple(argl) + val = apply(windowsc.wxMenuItem_SetBitmaps,(self.this,arg0.this,)+args) + return val + def SetFont(self,arg0): + val = windowsc.wxMenuItem_SetFont(self.this,arg0.this) + return val + def SetMarginWidth(self,arg0): + val = windowsc.wxMenuItem_SetMarginWidth(self.this,arg0) + return val + def SetTextColour(self,arg0): + val = windowsc.wxMenuItem_SetTextColour(self.this,arg0.this) + return val def DeleteSubMenu(self): val = windowsc.wxMenuItem_DeleteSubMenu(self.this) return val def __repr__(self): return "" class wxMenuItem(wxMenuItemPtr): - def __init__(self,this): - self.this = this + def __init__(self,*args) : + argl = map(None,args) + try: argl[0] = argl[0].this + except: pass + try: argl[5] = argl[5].this + except: pass + args = tuple(argl) + self.this = apply(windowsc.new_wxMenuItem,()+args) + self.thisown = 1 diff --git a/utils/wxPython/src/msw/windows2.cpp b/utils/wxPython/src/msw/windows2.cpp index 11bf56e2a4..42ea82fd16 100644 --- a/utils/wxPython/src/msw/windows2.cpp +++ b/utils/wxPython/src/msw/windows2.cpp @@ -128,8 +128,12 @@ static PyObject *_wrap_new_wxGridCell(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxGridCell")) return NULL; - _result = (wxGridCell *)new_wxGridCell(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGridCell *)new_wxGridCell(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -149,8 +153,12 @@ static PyObject *_wrap_delete_wxGridCell(PyObject *self, PyObject *args) { return NULL; } } - delete_wxGridCell(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxGridCell(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -171,9 +179,13 @@ static PyObject *_wrap_wxGridCell_GetTextValue(PyObject *self, PyObject *args) { return NULL; } } - wxString & _result_ref = wxGridCell_GetTextValue(_arg0); - _result = (wxString *) &_result_ref; { + wxPy_BEGIN_ALLOW_THREADS; + wxString & _result_ref = wxGridCell_GetTextValue(_arg0); + _result = (wxString *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } return _resultobj; @@ -201,10 +213,14 @@ static PyObject *_wrap_wxGridCell_SetTextValue(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxGridCell_SetTextValue(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCell_SetTextValue(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -230,9 +246,13 @@ static PyObject *_wrap_wxGridCell_GetFont(PyObject *self, PyObject *args) { return NULL; } } - wxFont & _result_ref = wxGridCell_GetFont(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont & _result_ref = wxGridCell_GetFont(_arg0); _result = (wxFont *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -260,8 +280,12 @@ static PyObject *_wrap_wxGridCell_SetFont(PyObject *self, PyObject *args) { return NULL; } } - wxGridCell_SetFont(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCell_SetFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -283,9 +307,13 @@ static PyObject *_wrap_wxGridCell_GetTextColour(PyObject *self, PyObject *args) return NULL; } } - wxColour & _result_ref = wxGridCell_GetTextColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGridCell_GetTextColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -313,8 +341,12 @@ static PyObject *_wrap_wxGridCell_SetTextColour(PyObject *self, PyObject *args) return NULL; } } - wxGridCell_SetTextColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCell_SetTextColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -336,9 +368,13 @@ static PyObject *_wrap_wxGridCell_GetBackgroundColour(PyObject *self, PyObject * return NULL; } } - wxColour & _result_ref = wxGridCell_GetBackgroundColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGridCell_GetBackgroundColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -366,8 +402,12 @@ static PyObject *_wrap_wxGridCell_SetBackgroundColour(PyObject *self, PyObject * return NULL; } } - wxGridCell_SetBackgroundColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCell_SetBackgroundColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -389,9 +429,13 @@ static PyObject *_wrap_wxGridCell_GetBackgroundBrush(PyObject *self, PyObject *a return NULL; } } - wxBrush & _result_ref = wxGridCell_GetBackgroundBrush(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxBrush & _result_ref = wxGridCell_GetBackgroundBrush(_arg0); _result = (wxBrush *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBrush_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -412,8 +456,12 @@ static PyObject *_wrap_wxGridCell_GetAlignment(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridCell_GetAlignment(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridCell_GetAlignment(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -433,8 +481,12 @@ static PyObject *_wrap_wxGridCell_SetAlignment(PyObject *self, PyObject *args) { return NULL; } } - wxGridCell_SetAlignment(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCell_SetAlignment(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -456,8 +508,12 @@ static PyObject *_wrap_wxGridCell_GetCellBitmap(PyObject *self, PyObject *args) return NULL; } } - _result = (wxBitmap *)wxGridCell_GetCellBitmap(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxBitmap *)wxGridCell_GetCellBitmap(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -485,8 +541,12 @@ static PyObject *_wrap_wxGridCell_SetCellBitmap(PyObject *self, PyObject *args) return NULL; } } - wxGridCell_SetCellBitmap(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGridCell_SetCellBitmap(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -551,8 +611,12 @@ static PyObject *_wrap_new_wxGrid(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxGrid *)new_wxGrid(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxGrid_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGrid *)new_wxGrid(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGrid_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -572,8 +636,12 @@ static PyObject *_wrap_wxGrid_AdjustScrollbars(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_AdjustScrollbars(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_AdjustScrollbars(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -598,8 +666,12 @@ static PyObject *_wrap_wxGrid_AppendCols(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - _result = (bool )wxGrid_AppendCols(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_AppendCols(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -623,8 +695,12 @@ static PyObject *_wrap_wxGrid_AppendRows(PyObject *self, PyObject *args) { } } _arg2 = (bool ) tempbool2; - _result = (bool )wxGrid_AppendRows(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_AppendRows(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -643,8 +719,12 @@ static PyObject *_wrap_wxGrid_BeginBatch(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_BeginBatch(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_BeginBatch(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -677,8 +757,12 @@ static PyObject *_wrap_wxGrid_CellHitTest(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxGrid_CellHitTest(_arg0,_arg1,_arg2,_arg3,_arg4); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_CellHitTest(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { PyObject *o; o = PyInt_FromLong((long) (*_arg3)); @@ -715,8 +799,12 @@ static PyObject *_wrap_wxGrid_CreateGrid(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxGrid_CreateGrid(_arg0,_arg1,_arg2,_arg3,_arg4); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_CreateGrid(_arg0,_arg1,_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -736,8 +824,12 @@ static PyObject *_wrap_wxGrid_CurrentCellVisible(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxGrid_CurrentCellVisible(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_CurrentCellVisible(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -762,8 +854,12 @@ static PyObject *_wrap_wxGrid_DeleteCols(PyObject *self, PyObject *args) { } } _arg3 = (bool ) tempbool3; - _result = (bool )wxGrid_DeleteCols(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_DeleteCols(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -788,8 +884,12 @@ static PyObject *_wrap_wxGrid_DeleteRows(PyObject *self, PyObject *args) { } } _arg3 = (bool ) tempbool3; - _result = (bool )wxGrid_DeleteRows(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_DeleteRows(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -808,8 +908,12 @@ static PyObject *_wrap_wxGrid_EndBatch(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_EndBatch(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_EndBatch(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -830,8 +934,12 @@ static PyObject *_wrap_wxGrid_GetBatchCount(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetBatchCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetBatchCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -854,8 +962,12 @@ static PyObject *_wrap_wxGrid_GetCell(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxGridCell *)wxGrid_GetCell(_arg0,_arg1,_arg2); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGridCell *)wxGrid_GetCell(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -878,8 +990,12 @@ static PyObject *_wrap_wxGrid_GetCellAlignment(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetCellAlignment(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetCellAlignment(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -899,8 +1015,12 @@ static PyObject *_wrap_wxGrid_GetDefCellAlignment(PyObject *self, PyObject *args return NULL; } } - _result = (int )wxGrid_GetDefCellAlignment(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetDefCellAlignment(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -923,9 +1043,13 @@ static PyObject *_wrap_wxGrid_GetCellBackgroundColour(PyObject *self, PyObject * return NULL; } } - wxColour & _result_ref = wxGrid_GetCellBackgroundColour(_arg0,_arg1,_arg2); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGrid_GetCellBackgroundColour(_arg0,_arg1,_arg2); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -947,9 +1071,13 @@ static PyObject *_wrap_wxGrid_GetDefCellBackgroundColour(PyObject *self, PyObjec return NULL; } } - wxColour & _result_ref = wxGrid_GetDefCellBackgroundColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGrid_GetDefCellBackgroundColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -973,9 +1101,13 @@ static PyObject *_wrap_wxGrid_GetCellTextColour(PyObject *self, PyObject *args) return NULL; } } - wxColour & _result_ref = wxGrid_GetCellTextColour(_arg0,_arg1,_arg2); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGrid_GetCellTextColour(_arg0,_arg1,_arg2); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -997,9 +1129,13 @@ static PyObject *_wrap_wxGrid_GetDefCellTextColour(PyObject *self, PyObject *arg return NULL; } } - wxColour & _result_ref = wxGrid_GetDefCellTextColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGrid_GetDefCellTextColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1023,9 +1159,13 @@ static PyObject *_wrap_wxGrid_GetCellTextFont(PyObject *self, PyObject *args) { return NULL; } } - wxFont & _result_ref = wxGrid_GetCellTextFont(_arg0,_arg1,_arg2); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont & _result_ref = wxGrid_GetCellTextFont(_arg0,_arg1,_arg2); _result = (wxFont *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1047,9 +1187,13 @@ static PyObject *_wrap_wxGrid_GetDefCellTextFont(PyObject *self, PyObject *args) return NULL; } } - wxFont & _result_ref = wxGrid_GetDefCellTextFont(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont & _result_ref = wxGrid_GetDefCellTextFont(_arg0); _result = (wxFont *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1072,9 +1216,13 @@ static PyObject *_wrap_wxGrid_GetCellValue(PyObject *self, PyObject *args) { return NULL; } } - wxString & _result_ref = wxGrid_GetCellValue(_arg0,_arg1,_arg2); - _result = (wxString *) &_result_ref; { + wxPy_BEGIN_ALLOW_THREADS; + wxString & _result_ref = wxGrid_GetCellValue(_arg0,_arg1,_arg2); + _result = (wxString *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } return _resultobj; @@ -1096,8 +1244,12 @@ static PyObject *_wrap_wxGrid_GetCols(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetCols(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetCols(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1118,8 +1270,12 @@ static PyObject *_wrap_wxGrid_GetColumnWidth(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetColumnWidth(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetColumnWidth(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1140,9 +1296,12 @@ static PyObject *_wrap_wxGrid_GetCurrentRect(PyObject *self, PyObject *args) { return NULL; } } - wxRect & _result_ref = wxGrid_GetCurrentRect(_arg0); - _result = (wxRect *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxRect (wxGrid_GetCurrentRect(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1163,8 +1322,12 @@ static PyObject *_wrap_wxGrid_GetCursorColumn(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetCursorColumn(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetCursorColumn(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1184,8 +1347,12 @@ static PyObject *_wrap_wxGrid_GetCursorRow(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetCursorRow(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetCursorRow(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1205,8 +1372,12 @@ static PyObject *_wrap_wxGrid_GetEditable(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxGrid_GetEditable(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_GetEditable(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1227,8 +1398,12 @@ static PyObject *_wrap_wxGrid_GetHorizScrollBar(PyObject *self, PyObject *args) return NULL; } } - _result = (wxScrollBar *)wxGrid_GetHorizScrollBar(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrollBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxScrollBar *)wxGrid_GetHorizScrollBar(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrollBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1250,8 +1425,12 @@ static PyObject *_wrap_wxGrid_GetLabelAlignment(PyObject *self, PyObject *args) return NULL; } } - _result = (int )wxGrid_GetLabelAlignment(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetLabelAlignment(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1272,9 +1451,13 @@ static PyObject *_wrap_wxGrid_GetLabelBackgroundColour(PyObject *self, PyObject return NULL; } } - wxColour & _result_ref = wxGrid_GetLabelBackgroundColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGrid_GetLabelBackgroundColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1296,8 +1479,12 @@ static PyObject *_wrap_wxGrid_GetLabelSize(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetLabelSize(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetLabelSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1318,9 +1505,13 @@ static PyObject *_wrap_wxGrid_GetLabelTextColour(PyObject *self, PyObject *args) return NULL; } } - wxColour & _result_ref = wxGrid_GetLabelTextColour(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxColour & _result_ref = wxGrid_GetLabelTextColour(_arg0); _result = (wxColour *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1342,9 +1533,13 @@ static PyObject *_wrap_wxGrid_GetLabelTextFont(PyObject *self, PyObject *args) { return NULL; } } - wxFont & _result_ref = wxGrid_GetLabelTextFont(_arg0); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxFont & _result_ref = wxGrid_GetLabelTextFont(_arg0); _result = (wxFont *) &_result_ref; - SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1367,9 +1562,13 @@ static PyObject *_wrap_wxGrid_GetLabelValue(PyObject *self, PyObject *args) { return NULL; } } - wxString & _result_ref = wxGrid_GetLabelValue(_arg0,_arg1,_arg2); - _result = (wxString *) &_result_ref; { + wxPy_BEGIN_ALLOW_THREADS; + wxString & _result_ref = wxGrid_GetLabelValue(_arg0,_arg1,_arg2); + _result = (wxString *) &_result_ref; + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST (*_result)); } return _resultobj; @@ -1392,8 +1591,12 @@ static PyObject *_wrap_wxGrid_GetRowHeight(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetRowHeight(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetRowHeight(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1413,8 +1616,12 @@ static PyObject *_wrap_wxGrid_GetRows(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetRows(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetRows(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1434,8 +1641,12 @@ static PyObject *_wrap_wxGrid_GetScrollPosX(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetScrollPosX(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetScrollPosX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1455,8 +1666,12 @@ static PyObject *_wrap_wxGrid_GetScrollPosY(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGrid_GetScrollPosY(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGrid_GetScrollPosY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1477,8 +1692,12 @@ static PyObject *_wrap_wxGrid_GetTextItem(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxTextCtrl *)wxGrid_GetTextItem(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTextCtrl *)wxGrid_GetTextItem(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTextCtrl_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1500,8 +1719,12 @@ static PyObject *_wrap_wxGrid_GetVertScrollBar(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxScrollBar *)wxGrid_GetVertScrollBar(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrollBar_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxScrollBar *)wxGrid_GetVertScrollBar(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrollBar_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1527,8 +1750,12 @@ static PyObject *_wrap_wxGrid_InsertCols(PyObject *self, PyObject *args) { } } _arg3 = (bool ) tempbool3; - _result = (bool )wxGrid_InsertCols(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_InsertCols(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1553,8 +1780,12 @@ static PyObject *_wrap_wxGrid_InsertRows(PyObject *self, PyObject *args) { } } _arg3 = (bool ) tempbool3; - _result = (bool )wxGrid_InsertRows(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGrid_InsertRows(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1576,8 +1807,12 @@ static PyObject *_wrap_wxGrid_OnActivate(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxGrid_OnActivate(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_OnActivate(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1600,8 +1835,12 @@ static PyObject *_wrap_wxGrid_SetCellAlignment(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetCellAlignment(_arg0,_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetCellAlignment(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1622,8 +1861,12 @@ static PyObject *_wrap_wxGrid_SetDefCellAlignment(PyObject *self, PyObject *args return NULL; } } - wxGrid_SetDefCellAlignment(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetDefCellAlignment(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1653,8 +1896,12 @@ static PyObject *_wrap_wxGrid_SetCellBackgroundColour(PyObject *self, PyObject * return NULL; } } - wxGrid_SetCellBackgroundColour(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetCellBackgroundColour(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1682,8 +1929,12 @@ static PyObject *_wrap_wxGrid_SetDefCellBackgroundColour(PyObject *self, PyObjec return NULL; } } - wxGrid_SetDefCellBackgroundColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetDefCellBackgroundColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1713,8 +1964,12 @@ static PyObject *_wrap_wxGrid_SetCellTextColour(PyObject *self, PyObject *args) return NULL; } } - wxGrid_SetCellTextColour(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetCellTextColour(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1742,8 +1997,12 @@ static PyObject *_wrap_wxGrid_SetDefCellTextColour(PyObject *self, PyObject *arg return NULL; } } - wxGrid_SetDefCellTextColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetDefCellTextColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1773,8 +2032,12 @@ static PyObject *_wrap_wxGrid_SetCellTextFont(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetCellTextFont(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetCellTextFont(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1802,8 +2065,12 @@ static PyObject *_wrap_wxGrid_SetDefCellTextFont(PyObject *self, PyObject *args) return NULL; } } - wxGrid_SetDefCellTextFont(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetDefCellTextFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1832,10 +2099,14 @@ static PyObject *_wrap_wxGrid_SetCellValue(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxGrid_SetCellValue(_arg0,*_arg1,_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetCellValue(_arg0,*_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1861,8 +2132,12 @@ static PyObject *_wrap_wxGrid_SetColumnWidth(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetColumnWidth(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetColumnWidth(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1890,8 +2165,12 @@ static PyObject *_wrap_wxGrid_SetDividerPen(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetDividerPen(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetDividerPen(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1914,8 +2193,12 @@ static PyObject *_wrap_wxGrid_SetEditable(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxGrid_SetEditable(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetEditable(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1937,8 +2220,12 @@ static PyObject *_wrap_wxGrid_SetGridCursor(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetGridCursor(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetGridCursor(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1960,8 +2247,12 @@ static PyObject *_wrap_wxGrid_SetLabelAlignment(PyObject *self, PyObject *args) return NULL; } } - wxGrid_SetLabelAlignment(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetLabelAlignment(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1989,8 +2280,12 @@ static PyObject *_wrap_wxGrid_SetLabelBackgroundColour(PyObject *self, PyObject return NULL; } } - wxGrid_SetLabelBackgroundColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetLabelBackgroundColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2012,8 +2307,12 @@ static PyObject *_wrap_wxGrid_SetLabelSize(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetLabelSize(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetLabelSize(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2041,8 +2340,12 @@ static PyObject *_wrap_wxGrid_SetLabelTextColour(PyObject *self, PyObject *args) return NULL; } } - wxGrid_SetLabelTextColour(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetLabelTextColour(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2070,8 +2373,12 @@ static PyObject *_wrap_wxGrid_SetLabelTextFont(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetLabelTextFont(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetLabelTextFont(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2100,10 +2407,14 @@ static PyObject *_wrap_wxGrid_SetLabelValue(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - wxGrid_SetLabelValue(_arg0,_arg1,*_arg2,_arg3); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetLabelValue(_arg0,_arg1,*_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj2) @@ -2129,8 +2440,12 @@ static PyObject *_wrap_wxGrid_SetRowHeight(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_SetRowHeight(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_SetRowHeight(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2150,8 +2465,12 @@ static PyObject *_wrap_wxGrid_UpdateDimensions(PyObject *self, PyObject *args) { return NULL; } } - wxGrid_UpdateDimensions(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxGrid_UpdateDimensions(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2181,8 +2500,12 @@ static PyObject *_wrap_wxGridEvent_m_row_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_row_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_row_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2202,8 +2525,12 @@ static PyObject *_wrap_wxGridEvent_m_row_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_row_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_row_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2224,8 +2551,12 @@ static PyObject *_wrap_wxGridEvent_m_col_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_col_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_col_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2245,8 +2576,12 @@ static PyObject *_wrap_wxGridEvent_m_col_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_col_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_col_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2267,8 +2602,12 @@ static PyObject *_wrap_wxGridEvent_m_x_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_x_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_x_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2288,8 +2627,12 @@ static PyObject *_wrap_wxGridEvent_m_x_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_x_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_x_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2310,8 +2653,12 @@ static PyObject *_wrap_wxGridEvent_m_y_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_y_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_y_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2331,8 +2678,12 @@ static PyObject *_wrap_wxGridEvent_m_y_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxGridEvent_m_y_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxGridEvent_m_y_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2355,8 +2706,12 @@ static PyObject *_wrap_wxGridEvent_m_control_set(PyObject *self, PyObject *args) } } _arg1 = (bool ) tempbool1; - _result = (bool )wxGridEvent_m_control_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGridEvent_m_control_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2376,8 +2731,12 @@ static PyObject *_wrap_wxGridEvent_m_control_get(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxGridEvent_m_control_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGridEvent_m_control_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2400,8 +2759,12 @@ static PyObject *_wrap_wxGridEvent_m_shift_set(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - _result = (bool )wxGridEvent_m_shift_set(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGridEvent_m_shift_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2421,8 +2784,12 @@ static PyObject *_wrap_wxGridEvent_m_shift_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxGridEvent_m_shift_get(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxGridEvent_m_shift_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2451,8 +2818,12 @@ static PyObject *_wrap_wxGridEvent_m_cell_set(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxGridCell *)wxGridEvent_m_cell_set(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGridCell *)wxGridEvent_m_cell_set(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2474,8 +2845,12 @@ static PyObject *_wrap_wxGridEvent_m_cell_get(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxGridCell *)wxGridEvent_m_cell_get(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxGridCell *)wxGridEvent_m_cell_get(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCell_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2512,8 +2887,12 @@ static PyObject *_wrap_wxNotebookEvent_GetSelection(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxNotebookEvent_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxNotebookEvent_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2533,8 +2912,12 @@ static PyObject *_wrap_wxNotebookEvent_GetOldSelection(PyObject *self, PyObject return NULL; } } - _result = (int )wxNotebookEvent_GetOldSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxNotebookEvent_GetOldSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2598,8 +2981,12 @@ static PyObject *_wrap_new_wxNotebook(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxNotebook *)new_wxNotebook(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxNotebook_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxNotebook *)new_wxNotebook(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxNotebook_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2620,8 +3007,12 @@ static PyObject *_wrap_wxNotebook_GetPageCount(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxNotebook_GetPageCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxNotebook_GetPageCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2642,8 +3033,12 @@ static PyObject *_wrap_wxNotebook_SetSelection(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxNotebook_SetSelection(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxNotebook_SetSelection(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2665,8 +3060,12 @@ static PyObject *_wrap_wxNotebook_AdvanceSelection(PyObject *self, PyObject *arg } } _arg1 = (bool ) tempbool1; - wxNotebook_AdvanceSelection(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxNotebook_AdvanceSelection(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2687,8 +3086,12 @@ static PyObject *_wrap_wxNotebook_GetSelection(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxNotebook_GetSelection(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxNotebook_GetSelection(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2716,10 +3119,14 @@ static PyObject *_wrap_wxNotebook_SetPageText(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _result = (bool )wxNotebook_SetPageText(_arg0,_arg1,*_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxNotebook_SetPageText(_arg0,_arg1,*_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj2) delete _arg2; @@ -2744,8 +3151,12 @@ static PyObject *_wrap_wxNotebook_GetPageText(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxNotebook_GetPageText(_arg0,_arg1)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxNotebook_GetPageText(_arg0,_arg1)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -2777,8 +3188,12 @@ static PyObject *_wrap_wxNotebook_SetImageList(PyObject *self, PyObject *args) { return NULL; } } - wxNotebook_SetImageList(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxNotebook_SetImageList(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -2800,8 +3215,12 @@ static PyObject *_wrap_wxNotebook_GetImageList(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxImageList *)wxNotebook_GetImageList(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxImageList *)wxNotebook_GetImageList(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxImageList_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -2823,8 +3242,12 @@ static PyObject *_wrap_wxNotebook_GetPageImage(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxNotebook_GetPageImage(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxNotebook_GetPageImage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2846,8 +3269,12 @@ static PyObject *_wrap_wxNotebook_SetPageImage(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxNotebook_SetPageImage(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxNotebook_SetPageImage(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2867,8 +3294,12 @@ static PyObject *_wrap_wxNotebook_GetRowCount(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxNotebook_GetRowCount(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxNotebook_GetRowCount(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2889,8 +3320,38 @@ static PyObject *_wrap_wxNotebook_DeletePage(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxNotebook_DeletePage(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxNotebook_DeletePage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxNotebook_RemovePage(_swigobj,_swigarg0) (_swigobj->RemovePage(_swigarg0)) +static PyObject *_wrap_wxNotebook_RemovePage(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxNotebook * _arg0; + int _arg1; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"si:wxNotebook_RemovePage",&_argc0,&_arg1)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxNotebook_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotebook_RemovePage. Expected _wxNotebook_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxNotebook_RemovePage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2910,8 +3371,12 @@ static PyObject *_wrap_wxNotebook_DeleteAllPages(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxNotebook_DeleteAllPages(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxNotebook_DeleteAllPages(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -2922,15 +3387,14 @@ static PyObject *_wrap_wxNotebook_AddPage(PyObject *self, PyObject *args) { wxNotebook * _arg0; wxWindow * _arg1; wxString * _arg2; - bool _arg3 = (0); + int _arg3 = (0); int _arg4 = -1; char * _argc0 = 0; char * _argc1 = 0; PyObject * _obj2 = 0; - int tempbool3; self = self; - if(!PyArg_ParseTuple(args,"ssO|ii:wxNotebook_AddPage",&_argc0,&_argc1,&_obj2,&tempbool3,&_arg4)) + if(!PyArg_ParseTuple(args,"ssO|ii:wxNotebook_AddPage",&_argc0,&_argc1,&_obj2,&_arg3,&_arg4)) return NULL; if (_argc0) { if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxNotebook_p")) { @@ -2949,11 +3413,14 @@ static PyObject *_wrap_wxNotebook_AddPage(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg2 = new wxString(PyString_AsString(_obj2)); + _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2)); } - _arg3 = (bool ) tempbool3; - _result = (bool )wxNotebook_AddPage(_arg0,_arg1,*_arg2,_arg3,_arg4); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxNotebook_AddPage(_arg0,_arg1,*_arg2,_arg3,_arg4); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj2) delete _arg2; @@ -2996,11 +3463,15 @@ static PyObject *_wrap_wxNotebook_InsertPage(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg3 = new wxString(PyString_AsString(_obj3)); + _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3)); } _arg4 = (bool ) tempbool4; - _result = (bool )wxNotebook_InsertPage(_arg0,_arg1,_arg2,*_arg3,_arg4,_arg5); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxNotebook_InsertPage(_arg0,_arg1,_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); { if (_obj3) delete _arg3; @@ -3026,12 +3497,44 @@ static PyObject *_wrap_wxNotebook_GetPage(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxNotebookPage *)wxNotebook_GetPage(_arg0,_arg1); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxNotebookPage_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxNotebookPage *)wxNotebook_GetPage(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxNotebookPage_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } +static void wxNotebook_ResizeChildren(wxNotebook *self) { + wxSizeEvent evt(self->GetClientSize()); + self->OnSize(evt); + } +static PyObject *_wrap_wxNotebook_ResizeChildren(PyObject *self, PyObject *args) { + PyObject * _resultobj; + wxNotebook * _arg0; + char * _argc0 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"s:wxNotebook_ResizeChildren",&_argc0)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxNotebook_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotebook_ResizeChildren. Expected _wxNotebook_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + wxNotebook_ResizeChildren(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); + _resultobj = Py_None; + return _resultobj; +} + static void *SwigwxSplitterWindowTowxWindow(void *ptr) { wxSplitterWindow *src; wxWindow *dest; @@ -3084,8 +3587,12 @@ static PyObject *_wrap_new_wxSplitterWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxSplitterWindow *)new_wxSplitterWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxSplitterWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSplitterWindow *)new_wxSplitterWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxSplitterWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3106,8 +3613,12 @@ static PyObject *_wrap_wxSplitterWindow_GetBorderSize(PyObject *self, PyObject * return NULL; } } - _result = (int )wxSplitterWindow_GetBorderSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSplitterWindow_GetBorderSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3127,8 +3638,12 @@ static PyObject *_wrap_wxSplitterWindow_GetMinimumPaneSize(PyObject *self, PyObj return NULL; } } - _result = (int )wxSplitterWindow_GetMinimumPaneSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSplitterWindow_GetMinimumPaneSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3148,8 +3663,12 @@ static PyObject *_wrap_wxSplitterWindow_GetSashPosition(PyObject *self, PyObject return NULL; } } - _result = (int )wxSplitterWindow_GetSashPosition(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSplitterWindow_GetSashPosition(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3169,8 +3688,12 @@ static PyObject *_wrap_wxSplitterWindow_GetSashSize(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxSplitterWindow_GetSashSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSplitterWindow_GetSashSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3190,8 +3713,12 @@ static PyObject *_wrap_wxSplitterWindow_GetSplitMode(PyObject *self, PyObject *a return NULL; } } - _result = (int )wxSplitterWindow_GetSplitMode(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSplitterWindow_GetSplitMode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3212,8 +3739,12 @@ static PyObject *_wrap_wxSplitterWindow_GetWindow1(PyObject *self, PyObject *arg return NULL; } } - _result = (wxWindow *)wxSplitterWindow_GetWindow1(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxSplitterWindow_GetWindow1(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3235,8 +3766,12 @@ static PyObject *_wrap_wxSplitterWindow_GetWindow2(PyObject *self, PyObject *arg return NULL; } } - _result = (wxWindow *)wxSplitterWindow_GetWindow2(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxSplitterWindow_GetWindow2(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3264,8 +3799,12 @@ static PyObject *_wrap_wxSplitterWindow_Initialize(PyObject *self, PyObject *arg return NULL; } } - wxSplitterWindow_Initialize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSplitterWindow_Initialize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3286,8 +3825,12 @@ static PyObject *_wrap_wxSplitterWindow_IsSplit(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxSplitterWindow_IsSplit(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxSplitterWindow_IsSplit(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3307,8 +3850,12 @@ static PyObject *_wrap_wxSplitterWindow_SetBorderSize(PyObject *self, PyObject * return NULL; } } - wxSplitterWindow_SetBorderSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSplitterWindow_SetBorderSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3330,8 +3877,12 @@ static PyObject *_wrap_wxSplitterWindow_SetSashPosition(PyObject *self, PyObject return NULL; } } - wxSplitterWindow_SetSashPosition(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSplitterWindow_SetSashPosition(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3352,8 +3903,12 @@ static PyObject *_wrap_wxSplitterWindow_SetSashSize(PyObject *self, PyObject *ar return NULL; } } - wxSplitterWindow_SetSashSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSplitterWindow_SetSashSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3374,8 +3929,12 @@ static PyObject *_wrap_wxSplitterWindow_SetMinimumPaneSize(PyObject *self, PyObj return NULL; } } - wxSplitterWindow_SetMinimumPaneSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSplitterWindow_SetMinimumPaneSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3396,8 +3955,12 @@ static PyObject *_wrap_wxSplitterWindow_SetSplitMode(PyObject *self, PyObject *a return NULL; } } - wxSplitterWindow_SetSplitMode(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSplitterWindow_SetSplitMode(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3435,8 +3998,12 @@ static PyObject *_wrap_wxSplitterWindow_SplitHorizontally(PyObject *self, PyObje return NULL; } } - _result = (bool )wxSplitterWindow_SplitHorizontally(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxSplitterWindow_SplitHorizontally(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3473,8 +4040,12 @@ static PyObject *_wrap_wxSplitterWindow_SplitVertically(PyObject *self, PyObject return NULL; } } - _result = (bool )wxSplitterWindow_SplitVertically(_arg0,_arg1,_arg2,_arg3); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxSplitterWindow_SplitVertically(_arg0,_arg1,_arg2,_arg3); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3502,8 +4073,12 @@ static PyObject *_wrap_wxSplitterWindow_Unsplit(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxSplitterWindow_Unsplit(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxSplitterWindow_Unsplit(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3524,8 +4099,12 @@ static PyObject *_wrap_new_wxTaskBarIcon(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxTaskBarIcon")) return NULL; - _result = (wxTaskBarIcon *)new_wxTaskBarIcon(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxTaskBarIcon_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxTaskBarIcon *)new_wxTaskBarIcon(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxTaskBarIcon_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -3545,8 +4124,12 @@ static PyObject *_wrap_delete_wxTaskBarIcon(PyObject *self, PyObject *args) { return NULL; } } - delete_wxTaskBarIcon(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxTaskBarIcon(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -3576,8 +4159,12 @@ static PyObject *_wrap_wxTaskBarIcon_SetIcon(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxTaskBarIcon_SetIcon(_arg0,*_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTaskBarIcon_SetIcon(_arg0,*_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3597,8 +4184,12 @@ static PyObject *_wrap_wxTaskBarIcon_RemoveIcon(PyObject *self, PyObject *args) return NULL; } } - _result = (bool )wxTaskBarIcon_RemoveIcon(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTaskBarIcon_RemoveIcon(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3626,8 +4217,12 @@ static PyObject *_wrap_wxTaskBarIcon_PopupMenu(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxTaskBarIcon_PopupMenu(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxTaskBarIcon_PopupMenu(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -3655,10 +4250,12 @@ static PyMethodDef windows2cMethods[] = { { "wxSplitterWindow_GetMinimumPaneSize", _wrap_wxSplitterWindow_GetMinimumPaneSize, 1 }, { "wxSplitterWindow_GetBorderSize", _wrap_wxSplitterWindow_GetBorderSize, 1 }, { "new_wxSplitterWindow", _wrap_new_wxSplitterWindow, 1 }, + { "wxNotebook_ResizeChildren", _wrap_wxNotebook_ResizeChildren, 1 }, { "wxNotebook_GetPage", _wrap_wxNotebook_GetPage, 1 }, { "wxNotebook_InsertPage", _wrap_wxNotebook_InsertPage, 1 }, { "wxNotebook_AddPage", _wrap_wxNotebook_AddPage, 1 }, { "wxNotebook_DeleteAllPages", _wrap_wxNotebook_DeleteAllPages, 1 }, + { "wxNotebook_RemovePage", _wrap_wxNotebook_RemovePage, 1 }, { "wxNotebook_DeletePage", _wrap_wxNotebook_DeletePage, 1 }, { "wxNotebook_GetRowCount", _wrap_wxNotebook_GetRowCount, 1 }, { "wxNotebook_SetPageImage", _wrap_wxNotebook_SetPageImage, 1 }, @@ -3856,6 +4453,7 @@ SWIGEXPORT(void,initwindows2c)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); @@ -3893,6 +4491,7 @@ SWIGEXPORT(void,initwindows2c)() { SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0); SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0); diff --git a/utils/wxPython/src/msw/windows2.py b/utils/wxPython/src/msw/windows2.py index 05a42fdf62..25ed395296 100644 --- a/utils/wxPython/src/msw/windows2.py +++ b/utils/wxPython/src/msw/windows2.py @@ -155,6 +155,7 @@ class wxGridPtr(wxPanelPtr): def GetCurrentRect(self): val = windows2c.wxGrid_GetCurrentRect(self.this) val = wxRectPtr(val) + val.thisown = 1 return val def GetCursorColumn(self): val = windows2c.wxGrid_GetCursorColumn(self.this) @@ -420,6 +421,9 @@ class wxNotebookPtr(wxControlPtr): def DeletePage(self,arg0): val = windows2c.wxNotebook_DeletePage(self.this,arg0) return val + def RemovePage(self,arg0): + val = windows2c.wxNotebook_RemovePage(self.this,arg0) + return val def DeleteAllPages(self): val = windows2c.wxNotebook_DeleteAllPages(self.this) return val @@ -432,6 +436,9 @@ class wxNotebookPtr(wxControlPtr): def GetPage(self,arg0): val = windows2c.wxNotebook_GetPage(self.this,arg0) return val + def ResizeChildren(self): + val = windows2c.wxNotebook_ResizeChildren(self.this) + return val def __repr__(self): return "" class wxNotebook(wxNotebookPtr): diff --git a/utils/wxPython/src/msw/windows3.cpp b/utils/wxPython/src/msw/windows3.cpp index 8e53cecd9c..c2ba858405 100644 --- a/utils/wxPython/src/msw/windows3.cpp +++ b/utils/wxPython/src/msw/windows3.cpp @@ -147,8 +147,12 @@ static PyObject *_wrap_wxSashEvent_SetEdge(PyObject *self, PyObject *args) { return NULL; } } - wxSashEvent_SetEdge(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashEvent_SetEdge(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -169,8 +173,12 @@ static PyObject *_wrap_wxSashEvent_GetEdge(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxSashEdgePosition )wxSashEvent_GetEdge(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSashEdgePosition )wxSashEvent_GetEdge(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -197,8 +205,12 @@ static PyObject *_wrap_wxSashEvent_SetDragRect(PyObject *self, PyObject *args) { return NULL; } } - wxSashEvent_SetDragRect(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashEvent_SetDragRect(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -220,8 +232,12 @@ static PyObject *_wrap_wxSashEvent_GetDragRect(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxRect (wxSashEvent_GetDragRect(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxRect (wxSashEvent_GetDragRect(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -242,8 +258,12 @@ static PyObject *_wrap_wxSashEvent_SetDragStatus(PyObject *self, PyObject *args) return NULL; } } - wxSashEvent_SetDragStatus(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashEvent_SetDragStatus(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -264,8 +284,12 @@ static PyObject *_wrap_wxSashEvent_GetDragStatus(PyObject *self, PyObject *args) return NULL; } } - _result = (wxSashDragStatus )wxSashEvent_GetDragStatus(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSashDragStatus )wxSashEvent_GetDragStatus(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -321,8 +345,12 @@ static PyObject *_wrap_new_wxSashWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxSashWindow *)new_wxSashWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxSashWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSashWindow *)new_wxSashWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxSashWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -344,8 +372,12 @@ static PyObject *_wrap_wxSashWindow_GetSashVisible(PyObject *self, PyObject *arg return NULL; } } - _result = (bool )wxSashWindow_GetSashVisible(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxSashWindow_GetSashVisible(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -365,8 +397,12 @@ static PyObject *_wrap_wxSashWindow_GetDefaultBorderSize(PyObject *self, PyObjec return NULL; } } - _result = (int )wxSashWindow_GetDefaultBorderSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSashWindow_GetDefaultBorderSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -387,8 +423,12 @@ static PyObject *_wrap_wxSashWindow_GetEdgeMargin(PyObject *self, PyObject *args return NULL; } } - _result = (int )wxSashWindow_GetEdgeMargin(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSashWindow_GetEdgeMargin(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -408,8 +448,12 @@ static PyObject *_wrap_wxSashWindow_GetExtraBorderSize(PyObject *self, PyObject return NULL; } } - _result = (int )wxSashWindow_GetExtraBorderSize(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSashWindow_GetExtraBorderSize(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -429,8 +473,12 @@ static PyObject *_wrap_wxSashWindow_GetMaximumSizeX(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxSashWindow_GetMaximumSizeX(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSashWindow_GetMaximumSizeX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -450,8 +498,12 @@ static PyObject *_wrap_wxSashWindow_GetMaximumSizeY(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxSashWindow_GetMaximumSizeY(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSashWindow_GetMaximumSizeY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -471,8 +523,12 @@ static PyObject *_wrap_wxSashWindow_GetMinimumSizeX(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxSashWindow_GetMinimumSizeX(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSashWindow_GetMinimumSizeX(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -492,8 +548,12 @@ static PyObject *_wrap_wxSashWindow_GetMinimumSizeY(PyObject *self, PyObject *ar return NULL; } } - _result = (int )wxSashWindow_GetMinimumSizeY(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxSashWindow_GetMinimumSizeY(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -514,8 +574,12 @@ static PyObject *_wrap_wxSashWindow_HasBorder(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxSashWindow_HasBorder(_arg0,_arg1); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxSashWindow_HasBorder(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -535,8 +599,12 @@ static PyObject *_wrap_wxSashWindow_SetDefaultBorderSize(PyObject *self, PyObjec return NULL; } } - wxSashWindow_SetDefaultBorderSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetDefaultBorderSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -557,8 +625,12 @@ static PyObject *_wrap_wxSashWindow_SetExtraBorderSize(PyObject *self, PyObject return NULL; } } - wxSashWindow_SetExtraBorderSize(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetExtraBorderSize(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -579,8 +651,12 @@ static PyObject *_wrap_wxSashWindow_SetMaximumSizeX(PyObject *self, PyObject *ar return NULL; } } - wxSashWindow_SetMaximumSizeX(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetMaximumSizeX(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -601,8 +677,12 @@ static PyObject *_wrap_wxSashWindow_SetMaximumSizeY(PyObject *self, PyObject *ar return NULL; } } - wxSashWindow_SetMaximumSizeY(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetMaximumSizeY(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -623,8 +703,12 @@ static PyObject *_wrap_wxSashWindow_SetMinimumSizeX(PyObject *self, PyObject *ar return NULL; } } - wxSashWindow_SetMinimumSizeX(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetMinimumSizeX(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -645,8 +729,12 @@ static PyObject *_wrap_wxSashWindow_SetMinimumSizeY(PyObject *self, PyObject *ar return NULL; } } - wxSashWindow_SetMinimumSizeY(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetMinimumSizeY(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -670,8 +758,12 @@ static PyObject *_wrap_wxSashWindow_SetSashVisible(PyObject *self, PyObject *arg } } _arg2 = (bool ) tempbool2; - wxSashWindow_SetSashVisible(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetSashVisible(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -695,8 +787,12 @@ static PyObject *_wrap_wxSashWindow_SetSashBorder(PyObject *self, PyObject *args } } _arg2 = (bool ) tempbool2; - wxSashWindow_SetSashBorder(_arg0,_arg1,_arg2); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashWindow_SetSashBorder(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -725,8 +821,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_SetRequestedLength(PyObject *self, return NULL; } } - wxQueryLayoutInfoEvent_SetRequestedLength(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxQueryLayoutInfoEvent_SetRequestedLength(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -747,8 +847,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_GetRequestedLength(PyObject *self, return NULL; } } - _result = (int )wxQueryLayoutInfoEvent_GetRequestedLength(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxQueryLayoutInfoEvent_GetRequestedLength(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -768,8 +872,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_SetFlags(PyObject *self, PyObject return NULL; } } - wxQueryLayoutInfoEvent_SetFlags(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxQueryLayoutInfoEvent_SetFlags(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -790,8 +898,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_GetFlags(PyObject *self, PyObject return NULL; } } - _result = (int )wxQueryLayoutInfoEvent_GetFlags(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxQueryLayoutInfoEvent_GetFlags(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -818,8 +930,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_SetSize(PyObject *self, PyObject * return NULL; } } - wxQueryLayoutInfoEvent_SetSize(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxQueryLayoutInfoEvent_SetSize(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -841,8 +957,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_GetSize(PyObject *self, PyObject * return NULL; } } - _result = new wxSize (wxQueryLayoutInfoEvent_GetSize(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxSize (wxQueryLayoutInfoEvent_GetSize(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -863,8 +983,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_SetOrientation(PyObject *self, PyO return NULL; } } - wxQueryLayoutInfoEvent_SetOrientation(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxQueryLayoutInfoEvent_SetOrientation(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -885,8 +1009,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_GetOrientation(PyObject *self, PyO return NULL; } } - _result = (wxLayoutOrientation )wxQueryLayoutInfoEvent_GetOrientation(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLayoutOrientation )wxQueryLayoutInfoEvent_GetOrientation(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -906,8 +1034,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_SetAlignment(PyObject *self, PyObj return NULL; } } - wxQueryLayoutInfoEvent_SetAlignment(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxQueryLayoutInfoEvent_SetAlignment(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -928,8 +1060,12 @@ static PyObject *_wrap_wxQueryLayoutInfoEvent_GetAlignment(PyObject *self, PyObj return NULL; } } - _result = (wxLayoutAlignment )wxQueryLayoutInfoEvent_GetAlignment(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLayoutAlignment )wxQueryLayoutInfoEvent_GetAlignment(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -957,8 +1093,12 @@ static PyObject *_wrap_wxCalculateLayoutEvent_SetFlags(PyObject *self, PyObject return NULL; } } - wxCalculateLayoutEvent_SetFlags(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxCalculateLayoutEvent_SetFlags(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -979,8 +1119,12 @@ static PyObject *_wrap_wxCalculateLayoutEvent_GetFlags(PyObject *self, PyObject return NULL; } } - _result = (int )wxCalculateLayoutEvent_GetFlags(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxCalculateLayoutEvent_GetFlags(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1007,8 +1151,12 @@ static PyObject *_wrap_wxCalculateLayoutEvent_SetRect(PyObject *self, PyObject * return NULL; } } - wxCalculateLayoutEvent_SetRect(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxCalculateLayoutEvent_SetRect(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1030,8 +1178,12 @@ static PyObject *_wrap_wxCalculateLayoutEvent_GetRect(PyObject *self, PyObject * return NULL; } } - _result = new wxRect (wxCalculateLayoutEvent_GetRect(_arg0)); - SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxRect (wxCalculateLayoutEvent_GetRect(_arg0)); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1096,8 +1248,12 @@ static PyObject *_wrap_new_wxSashLayoutWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxSashLayoutWindow *)new_wxSashLayoutWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxSashLayoutWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxSashLayoutWindow *)new_wxSashLayoutWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxSashLayoutWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1118,8 +1274,12 @@ static PyObject *_wrap_wxSashLayoutWindow_GetAlignment(PyObject *self, PyObject return NULL; } } - _result = (wxLayoutAlignment )wxSashLayoutWindow_GetAlignment(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLayoutAlignment )wxSashLayoutWindow_GetAlignment(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1139,8 +1299,12 @@ static PyObject *_wrap_wxSashLayoutWindow_GetOrientation(PyObject *self, PyObjec return NULL; } } - _result = (wxLayoutOrientation )wxSashLayoutWindow_GetOrientation(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLayoutOrientation )wxSashLayoutWindow_GetOrientation(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1160,8 +1324,12 @@ static PyObject *_wrap_wxSashLayoutWindow_SetAlignment(PyObject *self, PyObject return NULL; } } - wxSashLayoutWindow_SetAlignment(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashLayoutWindow_SetAlignment(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1189,8 +1357,12 @@ static PyObject *_wrap_wxSashLayoutWindow_SetDefaultSize(PyObject *self, PyObjec return NULL; } } - wxSashLayoutWindow_SetDefaultSize(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashLayoutWindow_SetDefaultSize(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1211,8 +1383,12 @@ static PyObject *_wrap_wxSashLayoutWindow_SetOrientation(PyObject *self, PyObjec return NULL; } } - wxSashLayoutWindow_SetOrientation(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxSashLayoutWindow_SetOrientation(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1226,8 +1402,12 @@ static PyObject *_wrap_new_wxLayoutAlgorithm(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxLayoutAlgorithm")) return NULL; - _result = (wxLayoutAlgorithm *)new_wxLayoutAlgorithm(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxLayoutAlgorithm_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxLayoutAlgorithm *)new_wxLayoutAlgorithm(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxLayoutAlgorithm_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -1247,8 +1427,12 @@ static PyObject *_wrap_delete_wxLayoutAlgorithm(PyObject *self, PyObject *args) return NULL; } } - delete_wxLayoutAlgorithm(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + delete_wxLayoutAlgorithm(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1285,8 +1469,12 @@ static PyObject *_wrap_wxLayoutAlgorithm_LayoutMDIFrame(PyObject *self, PyObject return NULL; } } - _result = (bool )wxLayoutAlgorithm_LayoutMDIFrame(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLayoutAlgorithm_LayoutMDIFrame(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1322,12 +1510,58 @@ static PyObject *_wrap_wxLayoutAlgorithm_LayoutFrame(PyObject *self, PyObject *a return NULL; } } - _result = (bool )wxLayoutAlgorithm_LayoutFrame(_arg0,_arg1,_arg2); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLayoutAlgorithm_LayoutFrame(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); + return _resultobj; +} + +#define wxLayoutAlgorithm_LayoutWindow(_swigobj,_swigarg0,_swigarg1) (_swigobj->LayoutWindow(_swigarg0,_swigarg1)) +static PyObject *_wrap_wxLayoutAlgorithm_LayoutWindow(PyObject *self, PyObject *args) { + PyObject * _resultobj; + bool _result; + wxLayoutAlgorithm * _arg0; + wxWindow * _arg1; + wxWindow * _arg2 = NULL; + char * _argc0 = 0; + char * _argc1 = 0; + char * _argc2 = 0; + + self = self; + if(!PyArg_ParseTuple(args,"ss|s:wxLayoutAlgorithm_LayoutWindow",&_argc0,&_argc1,&_argc2)) + return NULL; + if (_argc0) { + if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxLayoutAlgorithm_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxLayoutAlgorithm_LayoutWindow. Expected _wxLayoutAlgorithm_p."); + return NULL; + } + } + if (_argc1) { + if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxLayoutAlgorithm_LayoutWindow. Expected _wxWindow_p."); + return NULL; + } + } + if (_argc2) { + if (SWIG_GetPtr(_argc2,(void **) &_arg2,"_wxWindow_p")) { + PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxLayoutAlgorithm_LayoutWindow. Expected _wxWindow_p."); + return NULL; + } + } +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxLayoutAlgorithm_LayoutWindow(_arg0,_arg1,_arg2); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } static PyMethodDef windows3cMethods[] = { + { "wxLayoutAlgorithm_LayoutWindow", _wrap_wxLayoutAlgorithm_LayoutWindow, 1 }, { "wxLayoutAlgorithm_LayoutFrame", _wrap_wxLayoutAlgorithm_LayoutFrame, 1 }, { "wxLayoutAlgorithm_LayoutMDIFrame", _wrap_wxLayoutAlgorithm_LayoutMDIFrame, 1 }, { "delete_wxLayoutAlgorithm", _wrap_delete_wxLayoutAlgorithm, 1 }, @@ -1465,6 +1699,7 @@ SWIGEXPORT(void,initwindows3c)() { SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); @@ -1512,6 +1747,7 @@ SWIGEXPORT(void,initwindows3c)() { SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0); diff --git a/utils/wxPython/src/msw/windows3.py b/utils/wxPython/src/msw/windows3.py index c1b716e47b..cf20a91997 100644 --- a/utils/wxPython/src/msw/windows3.py +++ b/utils/wxPython/src/msw/windows3.py @@ -255,6 +255,13 @@ class wxLayoutAlgorithmPtr : args = tuple(argl) val = apply(windows3c.wxLayoutAlgorithm_LayoutFrame,(self.this,arg0.this,)+args) return val + def LayoutWindow(self,arg0,*args): + argl = map(None,args) + try: argl[0] = argl[0].this + except: pass + args = tuple(argl) + val = apply(windows3c.wxLayoutAlgorithm_LayoutWindow,(self.this,arg0.this,)+args) + return val def __repr__(self): return "" class wxLayoutAlgorithm(wxLayoutAlgorithmPtr): diff --git a/utils/wxPython/src/msw/wx.cpp b/utils/wxPython/src/msw/wx.cpp index 16e5518bd7..1f97b113f7 100644 --- a/utils/wxPython/src/msw/wx.cpp +++ b/utils/wxPython/src/msw/wx.cpp @@ -33,8 +33,9 @@ * and things like that. * * $Log$ - * Revision 1.8 1999/03/05 07:23:03 RD - * Minor wxPython changes for wxWin 2.0 + * Revision 1.9 1999/04/30 03:29:48 RD + * wxPython 2.0b9, first phase (win32) + * Added gobs of stuff, see wxPython/README.txt for details * ************************************************************************/ @@ -629,8 +630,10 @@ extern "C" SWIGEXPORT(void,initcmndlgsc)(); extern "C" SWIGEXPORT(void,initstattoolc)(); extern "C" SWIGEXPORT(void,initframesc)(); extern "C" SWIGEXPORT(void,initwindows3c)(); +extern "C" SWIGEXPORT(void,initimagec)(); #ifndef SEPARATE extern "C" SWIGEXPORT(void,initutilsc)(); +extern "C" SWIGEXPORT(void,initglcanvasc)(); #endif static int _wrap_wxPyDefaultPosition_set(PyObject *val) { char * tval; @@ -709,8 +712,12 @@ static PyObject *_wrap_new_wxPyApp(PyObject *self, PyObject *args) { self = self; if(!PyArg_ParseTuple(args,":new_wxPyApp")) return NULL; - _result = (wxPyApp *)new_wxPyApp(); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyApp_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxPyApp *)new_wxPyApp(); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyApp_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -731,8 +738,12 @@ static PyObject *_wrap_wxPyApp_GetAppName(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxPyApp_GetAppName(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxPyApp_GetAppName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -757,8 +768,12 @@ static PyObject *_wrap_wxPyApp_GetAuto3D(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxPyApp_GetAuto3D(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPyApp_GetAuto3D(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -778,8 +793,12 @@ static PyObject *_wrap_wxPyApp_GetClassName(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxPyApp_GetClassName(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxPyApp_GetClassName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -804,8 +823,12 @@ static PyObject *_wrap_wxPyApp_GetExitOnFrameDelete(PyObject *self, PyObject *ar return NULL; } } - _result = (bool )wxPyApp_GetExitOnFrameDelete(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPyApp_GetExitOnFrameDelete(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -825,8 +848,12 @@ static PyObject *_wrap_wxPyApp_GetPrintMode(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPyApp_GetPrintMode(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPyApp_GetPrintMode(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -847,8 +874,12 @@ static PyObject *_wrap_wxPyApp_GetTopWindow(PyObject *self, PyObject *args) { return NULL; } } - _result = (wxWindow *)wxPyApp_GetTopWindow(_arg0); - SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (wxWindow *)wxPyApp_GetTopWindow(_arg0); + + wxPy_END_ALLOW_THREADS; +} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p"); _resultobj = Py_BuildValue("s",_ptemp); return _resultobj; } @@ -869,8 +900,12 @@ static PyObject *_wrap_wxPyApp_GetVendorName(PyObject *self, PyObject *args) { return NULL; } } - _result = new wxString (wxPyApp_GetVendorName(_arg0)); { + wxPy_BEGIN_ALLOW_THREADS; + _result = new wxString (wxPyApp_GetVendorName(_arg0)); + + wxPy_END_ALLOW_THREADS; +}{ _resultobj = PyString_FromString(WXSTRINGCAST *(_result)); } { @@ -894,8 +929,12 @@ static PyObject *_wrap_wxPyApp_Dispatch(PyObject *self, PyObject *args) { return NULL; } } - wxPyApp_Dispatch(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_Dispatch(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -915,8 +954,12 @@ static PyObject *_wrap_wxPyApp_ExitMainLoop(PyObject *self, PyObject *args) { return NULL; } } - wxPyApp_ExitMainLoop(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_ExitMainLoop(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -937,8 +980,12 @@ static PyObject *_wrap_wxPyApp_Initialized(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxPyApp_Initialized(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPyApp_Initialized(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -958,8 +1005,12 @@ static PyObject *_wrap_wxPyApp_MainLoop(PyObject *self, PyObject *args) { return NULL; } } - _result = (int )wxPyApp_MainLoop(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (int )wxPyApp_MainLoop(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -979,8 +1030,12 @@ static PyObject *_wrap_wxPyApp_Pending(PyObject *self, PyObject *args) { return NULL; } } - _result = (bool )wxPyApp_Pending(_arg0); - _resultobj = Py_BuildValue("i",_result); +{ + wxPy_BEGIN_ALLOW_THREADS; + _result = (bool )wxPyApp_Pending(_arg0); + + wxPy_END_ALLOW_THREADS; +} _resultobj = Py_BuildValue("i",_result); return _resultobj; } @@ -1006,10 +1061,14 @@ static PyObject *_wrap_wxPyApp_SetAppName(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxPyApp_SetAppName(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_SetAppName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1036,8 +1095,12 @@ static PyObject *_wrap_wxPyApp_SetAuto3D(PyObject *self, PyObject *args) { } } _arg1 = (bool ) tempbool1; - wxPyApp_SetAuto3D(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_SetAuto3D(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1064,10 +1127,14 @@ static PyObject *_wrap_wxPyApp_SetClassName(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxPyApp_SetClassName(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_SetClassName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1094,8 +1161,12 @@ static PyObject *_wrap_wxPyApp_SetExitOnFrameDelete(PyObject *self, PyObject *ar } } _arg1 = (bool ) tempbool1; - wxPyApp_SetExitOnFrameDelete(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_SetExitOnFrameDelete(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1116,8 +1187,12 @@ static PyObject *_wrap_wxPyApp_SetPrintMode(PyObject *self, PyObject *args) { return NULL; } } - wxPyApp_SetPrintMode(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_SetPrintMode(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1145,8 +1220,12 @@ static PyObject *_wrap_wxPyApp_SetTopWindow(PyObject *self, PyObject *args) { return NULL; } } - wxPyApp_SetTopWindow(_arg0,_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_SetTopWindow(_arg0,_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1173,10 +1252,14 @@ static PyObject *_wrap_wxPyApp_SetVendorName(PyObject *self, PyObject *args) { PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - _arg1 = new wxString(PyString_AsString(_obj1)); + _arg1 = new wxString(PyString_AsString(_obj1), PyString_Size(_obj1)); } - wxPyApp_SetVendorName(_arg0,*_arg1); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_SetVendorName(_arg0,*_arg1); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; { if (_obj1) @@ -1200,8 +1283,12 @@ static PyObject *_wrap_wxPyApp_AfterMainLoop(PyObject *self, PyObject *args) { return NULL; } } - wxPyApp_AfterMainLoop(_arg0); - Py_INCREF(Py_None); +{ + wxPy_BEGIN_ALLOW_THREADS; + wxPyApp_AfterMainLoop(_arg0); + + wxPy_END_ALLOW_THREADS; +} Py_INCREF(Py_None); _resultobj = Py_None; return _resultobj; } @@ -1331,6 +1418,7 @@ SWIGEXPORT(void,initwxc)() { PyDict_SetItemString(d,"wxSL_SELRANGE", PyInt_FromLong((long) wxSL_SELRANGE)); PyDict_SetItemString(d,"wxSB_HORIZONTAL", PyInt_FromLong((long) wxSB_HORIZONTAL)); PyDict_SetItemString(d,"wxSB_VERTICAL", PyInt_FromLong((long) wxSB_VERTICAL)); + PyDict_SetItemString(d,"wxST_SIZEGRIP", PyInt_FromLong((long) wxST_SIZEGRIP)); PyDict_SetItemString(d,"wxBU_AUTODRAW", PyInt_FromLong((long) wxBU_AUTODRAW)); PyDict_SetItemString(d,"wxBU_NOAUTODRAW", PyInt_FromLong((long) wxBU_NOAUTODRAW)); PyDict_SetItemString(d,"wxTR_HAS_BUTTONS", PyInt_FromLong((long) wxTR_HAS_BUTTONS)); @@ -1360,10 +1448,6 @@ SWIGEXPORT(void,initwxc)() { PyDict_SetItemString(d,"wxSP_NOBORDER", PyInt_FromLong((long) wxSP_NOBORDER)); PyDict_SetItemString(d,"wxSP_3D", PyInt_FromLong((long) wxSP_3D)); PyDict_SetItemString(d,"wxSP_BORDER", PyInt_FromLong((long) wxSP_BORDER)); - PyDict_SetItemString(d,"wxTAB_MULTILINE", PyInt_FromLong((long) wxTAB_MULTILINE)); - PyDict_SetItemString(d,"wxTAB_RIGHTJUSTIFY", PyInt_FromLong((long) wxTAB_RIGHTJUSTIFY)); - PyDict_SetItemString(d,"wxTAB_FIXEDWIDTH", PyInt_FromLong((long) wxTAB_FIXEDWIDTH)); - PyDict_SetItemString(d,"wxTAB_OWNERDRAW", PyInt_FromLong((long) wxTAB_OWNERDRAW)); PyDict_SetItemString(d,"wxFLOOD_SURFACE", PyInt_FromLong((long) wxFLOOD_SURFACE)); PyDict_SetItemString(d,"wxFLOOD_BORDER", PyInt_FromLong((long) wxFLOOD_BORDER)); PyDict_SetItemString(d,"wxODDEVEN_RULE", PyInt_FromLong((long) wxODDEVEN_RULE)); @@ -1436,6 +1520,7 @@ SWIGEXPORT(void,initwxc)() { PyDict_SetItemString(d,"wxID_APPLY", PyInt_FromLong((long) wxID_APPLY)); PyDict_SetItemString(d,"wxID_YES", PyInt_FromLong((long) wxID_YES)); PyDict_SetItemString(d,"wxID_NO", PyInt_FromLong((long) wxID_NO)); + PyDict_SetItemString(d,"wxID_STATIC", PyInt_FromLong((long) wxID_STATIC)); PyDict_SetItemString(d,"wxBITMAP_TYPE_BMP", PyInt_FromLong((long) wxBITMAP_TYPE_BMP)); PyDict_SetItemString(d,"wxBITMAP_TYPE_BMP_RESOURCE", PyInt_FromLong((long) wxBITMAP_TYPE_BMP_RESOURCE)); PyDict_SetItemString(d,"wxBITMAP_TYPE_ICO", PyInt_FromLong((long) wxBITMAP_TYPE_ICO)); @@ -1454,6 +1539,7 @@ SWIGEXPORT(void,initwxc)() { PyDict_SetItemString(d,"wxBITMAP_TYPE_PNG_RESOURCE", PyInt_FromLong((long) wxBITMAP_TYPE_PNG_RESOURCE)); PyDict_SetItemString(d,"wxBITMAP_TYPE_ANY", PyInt_FromLong((long) wxBITMAP_TYPE_ANY)); PyDict_SetItemString(d,"wxBITMAP_TYPE_RESOURCE", PyInt_FromLong((long) wxBITMAP_TYPE_RESOURCE)); + PyDict_SetItemString(d,"wxBITMAP_TYPE_JPEG", PyInt_FromLong((long) wxBITMAP_TYPE_JPEG)); PyDict_SetItemString(d,"wxOPEN", PyInt_FromLong((long) wxOPEN)); PyDict_SetItemString(d,"wxSAVE", PyInt_FromLong((long) wxSAVE)); PyDict_SetItemString(d,"wxHIDE_READONLY", PyInt_FromLong((long) wxHIDE_READONLY)); @@ -1461,10 +1547,6 @@ SWIGEXPORT(void,initwxc)() { PyDict_SetItemString(d,"wxACCEL_ALT", PyInt_FromLong((long) wxACCEL_ALT)); PyDict_SetItemString(d,"wxACCEL_CTRL", PyInt_FromLong((long) wxACCEL_CTRL)); PyDict_SetItemString(d,"wxACCEL_SHIFT", PyInt_FromLong((long) wxACCEL_SHIFT)); - PyDict_SetItemString(d,"ERR_PARAM", PyInt_FromLong((long) ERR_PARAM)); - PyDict_SetItemString(d,"ERR_NODATA", PyInt_FromLong((long) ERR_NODATA)); - PyDict_SetItemString(d,"ERR_CANCEL", PyInt_FromLong((long) ERR_CANCEL)); - PyDict_SetItemString(d,"ERR_SUCCESS", PyInt_FromLong((long) ERR_SUCCESS)); PyDict_SetItemString(d,"wxDEFAULT", PyInt_FromLong((long) wxDEFAULT)); PyDict_SetItemString(d,"wxDECORATIVE", PyInt_FromLong((long) wxDECORATIVE)); PyDict_SetItemString(d,"wxROMAN", PyInt_FromLong((long) wxROMAN)); @@ -1618,6 +1700,73 @@ SWIGEXPORT(void,initwxc)() { PyDict_SetItemString(d,"wxCURSOR_WAIT", PyInt_FromLong((long) wxCURSOR_WAIT)); PyDict_SetItemString(d,"wxCURSOR_WATCH", PyInt_FromLong((long) wxCURSOR_WATCH)); PyDict_SetItemString(d,"wxCURSOR_BLANK", PyInt_FromLong((long) wxCURSOR_BLANK)); + PyDict_SetItemString(d,"wxPAPER_NONE", PyInt_FromLong((long) wxPAPER_NONE)); + PyDict_SetItemString(d,"wxPAPER_LETTER", PyInt_FromLong((long) wxPAPER_LETTER)); + PyDict_SetItemString(d,"wxPAPER_LEGAL", PyInt_FromLong((long) wxPAPER_LEGAL)); + PyDict_SetItemString(d,"wxPAPER_A4", PyInt_FromLong((long) wxPAPER_A4)); + PyDict_SetItemString(d,"wxPAPER_CSHEET", PyInt_FromLong((long) wxPAPER_CSHEET)); + PyDict_SetItemString(d,"wxPAPER_DSHEET", PyInt_FromLong((long) wxPAPER_DSHEET)); + PyDict_SetItemString(d,"wxPAPER_ESHEET", PyInt_FromLong((long) wxPAPER_ESHEET)); + PyDict_SetItemString(d,"wxPAPER_LETTERSMALL", PyInt_FromLong((long) wxPAPER_LETTERSMALL)); + PyDict_SetItemString(d,"wxPAPER_TABLOID", PyInt_FromLong((long) wxPAPER_TABLOID)); + PyDict_SetItemString(d,"wxPAPER_LEDGER", PyInt_FromLong((long) wxPAPER_LEDGER)); + PyDict_SetItemString(d,"wxPAPER_STATEMENT", PyInt_FromLong((long) wxPAPER_STATEMENT)); + PyDict_SetItemString(d,"wxPAPER_EXECUTIVE", PyInt_FromLong((long) wxPAPER_EXECUTIVE)); + PyDict_SetItemString(d,"wxPAPER_A3", PyInt_FromLong((long) wxPAPER_A3)); + PyDict_SetItemString(d,"wxPAPER_A4SMALL", PyInt_FromLong((long) wxPAPER_A4SMALL)); + PyDict_SetItemString(d,"wxPAPER_A5", PyInt_FromLong((long) wxPAPER_A5)); + PyDict_SetItemString(d,"wxPAPER_B4", PyInt_FromLong((long) wxPAPER_B4)); + PyDict_SetItemString(d,"wxPAPER_B5", PyInt_FromLong((long) wxPAPER_B5)); + PyDict_SetItemString(d,"wxPAPER_FOLIO", PyInt_FromLong((long) wxPAPER_FOLIO)); + PyDict_SetItemString(d,"wxPAPER_QUARTO", PyInt_FromLong((long) wxPAPER_QUARTO)); + PyDict_SetItemString(d,"wxPAPER_10X14", PyInt_FromLong((long) wxPAPER_10X14)); + PyDict_SetItemString(d,"wxPAPER_11X17", PyInt_FromLong((long) wxPAPER_11X17)); + PyDict_SetItemString(d,"wxPAPER_NOTE", PyInt_FromLong((long) wxPAPER_NOTE)); + PyDict_SetItemString(d,"wxPAPER_ENV_9", PyInt_FromLong((long) wxPAPER_ENV_9)); + PyDict_SetItemString(d,"wxPAPER_ENV_10", PyInt_FromLong((long) wxPAPER_ENV_10)); + PyDict_SetItemString(d,"wxPAPER_ENV_11", PyInt_FromLong((long) wxPAPER_ENV_11)); + PyDict_SetItemString(d,"wxPAPER_ENV_12", PyInt_FromLong((long) wxPAPER_ENV_12)); + PyDict_SetItemString(d,"wxPAPER_ENV_14", PyInt_FromLong((long) wxPAPER_ENV_14)); + PyDict_SetItemString(d,"wxPAPER_ENV_DL", PyInt_FromLong((long) wxPAPER_ENV_DL)); + PyDict_SetItemString(d,"wxPAPER_ENV_C5", PyInt_FromLong((long) wxPAPER_ENV_C5)); + PyDict_SetItemString(d,"wxPAPER_ENV_C3", PyInt_FromLong((long) wxPAPER_ENV_C3)); + PyDict_SetItemString(d,"wxPAPER_ENV_C4", PyInt_FromLong((long) wxPAPER_ENV_C4)); + PyDict_SetItemString(d,"wxPAPER_ENV_C6", PyInt_FromLong((long) wxPAPER_ENV_C6)); + PyDict_SetItemString(d,"wxPAPER_ENV_C65", PyInt_FromLong((long) wxPAPER_ENV_C65)); + PyDict_SetItemString(d,"wxPAPER_ENV_B4", PyInt_FromLong((long) wxPAPER_ENV_B4)); + PyDict_SetItemString(d,"wxPAPER_ENV_B5", PyInt_FromLong((long) wxPAPER_ENV_B5)); + PyDict_SetItemString(d,"wxPAPER_ENV_B6", PyInt_FromLong((long) wxPAPER_ENV_B6)); + PyDict_SetItemString(d,"wxPAPER_ENV_ITALY", PyInt_FromLong((long) wxPAPER_ENV_ITALY)); + PyDict_SetItemString(d,"wxPAPER_ENV_MONARCH", PyInt_FromLong((long) wxPAPER_ENV_MONARCH)); + PyDict_SetItemString(d,"wxPAPER_ENV_PERSONAL", PyInt_FromLong((long) wxPAPER_ENV_PERSONAL)); + PyDict_SetItemString(d,"wxPAPER_FANFOLD_US", PyInt_FromLong((long) wxPAPER_FANFOLD_US)); + PyDict_SetItemString(d,"wxPAPER_FANFOLD_STD_GERMAN", PyInt_FromLong((long) wxPAPER_FANFOLD_STD_GERMAN)); + PyDict_SetItemString(d,"wxPAPER_FANFOLD_LGL_GERMAN", PyInt_FromLong((long) wxPAPER_FANFOLD_LGL_GERMAN)); + PyDict_SetItemString(d,"wxPAPER_ISO_B4", PyInt_FromLong((long) wxPAPER_ISO_B4)); + PyDict_SetItemString(d,"wxPAPER_JAPANESE_POSTCARD", PyInt_FromLong((long) wxPAPER_JAPANESE_POSTCARD)); + PyDict_SetItemString(d,"wxPAPER_9X11", PyInt_FromLong((long) wxPAPER_9X11)); + PyDict_SetItemString(d,"wxPAPER_10X11", PyInt_FromLong((long) wxPAPER_10X11)); + PyDict_SetItemString(d,"wxPAPER_15X11", PyInt_FromLong((long) wxPAPER_15X11)); + PyDict_SetItemString(d,"wxPAPER_ENV_INVITE", PyInt_FromLong((long) wxPAPER_ENV_INVITE)); + PyDict_SetItemString(d,"wxPAPER_LETTER_EXTRA", PyInt_FromLong((long) wxPAPER_LETTER_EXTRA)); + PyDict_SetItemString(d,"wxPAPER_LEGAL_EXTRA", PyInt_FromLong((long) wxPAPER_LEGAL_EXTRA)); + PyDict_SetItemString(d,"wxPAPER_TABLOID_EXTRA", PyInt_FromLong((long) wxPAPER_TABLOID_EXTRA)); + PyDict_SetItemString(d,"wxPAPER_A4_EXTRA", PyInt_FromLong((long) wxPAPER_A4_EXTRA)); + PyDict_SetItemString(d,"wxPAPER_LETTER_TRANSVERSE", PyInt_FromLong((long) wxPAPER_LETTER_TRANSVERSE)); + PyDict_SetItemString(d,"wxPAPER_A4_TRANSVERSE", PyInt_FromLong((long) wxPAPER_A4_TRANSVERSE)); + PyDict_SetItemString(d,"wxPAPER_LETTER_EXTRA_TRANSVERSE", PyInt_FromLong((long) wxPAPER_LETTER_EXTRA_TRANSVERSE)); + PyDict_SetItemString(d,"wxPAPER_A_PLUS", PyInt_FromLong((long) wxPAPER_A_PLUS)); + PyDict_SetItemString(d,"wxPAPER_B_PLUS", PyInt_FromLong((long) wxPAPER_B_PLUS)); + PyDict_SetItemString(d,"wxPAPER_LETTER_PLUS", PyInt_FromLong((long) wxPAPER_LETTER_PLUS)); + PyDict_SetItemString(d,"wxPAPER_A4_PLUS", PyInt_FromLong((long) wxPAPER_A4_PLUS)); + PyDict_SetItemString(d,"wxPAPER_A5_TRANSVERSE", PyInt_FromLong((long) wxPAPER_A5_TRANSVERSE)); + PyDict_SetItemString(d,"wxPAPER_B5_TRANSVERSE", PyInt_FromLong((long) wxPAPER_B5_TRANSVERSE)); + PyDict_SetItemString(d,"wxPAPER_A3_EXTRA", PyInt_FromLong((long) wxPAPER_A3_EXTRA)); + PyDict_SetItemString(d,"wxPAPER_A5_EXTRA", PyInt_FromLong((long) wxPAPER_A5_EXTRA)); + PyDict_SetItemString(d,"wxPAPER_B5_EXTRA", PyInt_FromLong((long) wxPAPER_B5_EXTRA)); + PyDict_SetItemString(d,"wxPAPER_A2", PyInt_FromLong((long) wxPAPER_A2)); + PyDict_SetItemString(d,"wxPAPER_A3_TRANSVERSE", PyInt_FromLong((long) wxPAPER_A3_TRANSVERSE)); + PyDict_SetItemString(d,"wxPAPER_A3_EXTRA_TRANSVERSE", PyInt_FromLong((long) wxPAPER_A3_EXTRA_TRANSVERSE)); PyDict_SetItemString(d,"FALSE", PyInt_FromLong((long) 0)); PyDict_SetItemString(d,"false", PyInt_FromLong((long) 0)); PyDict_SetItemString(d,"TRUE", PyInt_FromLong((long) 1)); @@ -1755,7 +1904,7 @@ SWIGEXPORT(void,initwxc)() { PyDict_SetItemString(d,"wxEVT_COMMAND_TAB_SEL_CHANGING", PyInt_FromLong((long) wxEVT_COMMAND_TAB_SEL_CHANGING)); PyDict_SetItemString(d,"wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED", PyInt_FromLong((long) wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)); PyDict_SetItemString(d,"wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING", PyInt_FromLong((long) wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)); - PyDict_SetItemString(d,"__version__", PyString_FromString("2.0b6")); + PyDict_SetItemString(d,"__version__", PyString_FromString("2.0b9")); PyDict_SetItemString(d,"cvar", SWIG_globals); SWIG_addvarlink(SWIG_globals,"wxPyDefaultPosition",_wrap_wxPyDefaultPosition_get, _wrap_wxPyDefaultPosition_set); SWIG_addvarlink(SWIG_globals,"wxPyDefaultSize",_wrap_wxPyDefaultSize_get, _wrap_wxPyDefaultSize_set); @@ -1780,8 +1929,12 @@ SWIGEXPORT(void,initwxc)() { initstattoolc(); initframesc(); initwindows3c(); + initimagec(); #ifndef SEPARATE initutilsc(); +#ifdef WITH_GLCANVAS + initglcanvasc(); +#endif #endif /* * These are the pointer type-equivalency mappings. @@ -1792,22 +1945,29 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0); SWIG_RegisterMapping("_signed_long","_long",0); SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0); + SWIG_RegisterMapping("_class_wxJPEGHandler","_wxJPEGHandler",0); + SWIG_RegisterMapping("_wxBMPHandler","_class_wxBMPHandler",0); + SWIG_RegisterMapping("_wxImage","_class_wxImage",0); SWIG_RegisterMapping("_wxFontData","_class_wxFontData",0); SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0); SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0); + SWIG_RegisterMapping("_class_wxPyTreeItemData","_wxPyTreeItemData",0); SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxPyApp",SwigwxPyAppTowxEvtHandler); SWIG_RegisterMapping("_class_wxEvtHandler","_wxPyApp",SwigwxPyAppTowxEvtHandler); SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0); SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0); + SWIG_RegisterMapping("_wxGIFHandler","_class_wxGIFHandler",0); SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0); SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0); + SWIG_RegisterMapping("_wxImageHandler","_class_wxImageHandler",0); SWIG_RegisterMapping("_class_wxTreeCtrl","_wxTreeCtrl",0); SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0); SWIG_RegisterMapping("_wxMask","_class_wxMask",0); SWIG_RegisterMapping("_wxGrid","_class_wxGrid",0); - SWIG_RegisterMapping("_wxPageSetupData","_class_wxPageSetupData",0); + SWIG_RegisterMapping("_wxPNGHandler","_class_wxPNGHandler",0); SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0); SWIG_RegisterMapping("_class_wxColourData","_wxColourData",0); + SWIG_RegisterMapping("_class_wxPageSetupDialogData","_wxPageSetupDialogData",0); SWIG_RegisterMapping("_wxPen","_class_wxPen",0); SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0); SWIG_RegisterMapping("_byte","_unsigned_char",0); @@ -1822,12 +1982,14 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0); SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0); SWIG_RegisterMapping("_wxSashWindow","_class_wxSashWindow",0); + SWIG_RegisterMapping("_class_wxPrintDialogData","_wxPrintDialogData",0); SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0); SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0); SWIG_RegisterMapping("_class_wxSashEvent","_wxSashEvent",0); SWIG_RegisterMapping("_wxDC","_class_wxDC",0); SWIG_RegisterMapping("_wxListEvent","_class_wxListEvent",0); SWIG_RegisterMapping("_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0); + SWIG_RegisterMapping("_class_wxBMPHandler","_wxBMPHandler",0); SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0); SWIG_RegisterMapping("_wxSashLayoutWindow","_class_wxSashLayoutWindow",0); SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0); @@ -1836,15 +1998,17 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0); SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0); SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0); + SWIG_RegisterMapping("_class_wxGIFHandler","_wxGIFHandler",0); SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0); SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0); SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0); + SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0); SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0); SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0); SWIG_RegisterMapping("_class_wxMask","_wxMask",0); SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0); SWIG_RegisterMapping("_class_wxGrid","_wxGrid",0); - SWIG_RegisterMapping("_class_wxPageSetupData","_wxPageSetupData",0); + SWIG_RegisterMapping("_class_wxPNGHandler","_wxPNGHandler",0); SWIG_RegisterMapping("_wxColour","_class_wxColour",0); SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0); SWIG_RegisterMapping("_wxPageSetupDialog","_class_wxPageSetupDialog",0); @@ -1866,11 +2030,11 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_wxRect","_class_wxRect",0); SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0); SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0); + SWIG_RegisterMapping("_class_wxImage","_wxImage",0); SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0); SWIG_RegisterMapping("_class_wxSashLayoutWindow","_wxSashLayoutWindow",0); SWIG_RegisterMapping("_class_wxButton","_wxButton",0); SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0); - SWIG_RegisterMapping("_wxTreeItemData","_class_wxTreeItemData",0); SWIG_RegisterMapping("_class_wxFontData","_wxFontData",0); SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0); SWIG_RegisterMapping("_wxTaskBarIcon","_class_wxTaskBarIcon",0); @@ -1881,11 +2045,10 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0); SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0); SWIG_RegisterMapping("_wxColourDialog","_class_wxColourDialog",0); - SWIG_RegisterMapping("_wxPrintData","_class_wxPrintData",0); SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0); SWIG_RegisterMapping("_wxMessageDialog","_class_wxMessageDialog",0); + SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0); SWIG_RegisterMapping("_wxTextEntryDialog","_class_wxTextEntryDialog",0); - SWIG_RegisterMapping("_wxConfig","_class_wxConfig",0); SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0); SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0); SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0); @@ -1942,6 +2105,7 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0); SWIG_RegisterMapping("_wxSplitterWindow","_class_wxSplitterWindow",0); SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0); + SWIG_RegisterMapping("_wxPrintDialogData","_class_wxPrintDialogData",0); SWIG_RegisterMapping("_class_wxFont","_wxFont",0); SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0); SWIG_RegisterMapping("_wxSashEvent","_class_wxSashEvent",0); @@ -1967,6 +2131,7 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0); SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0); SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0); + SWIG_RegisterMapping("_class_wxImageHandler","_wxImageHandler",0); SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0); SWIG_RegisterMapping("_wxTreeItemId","_class_wxTreeItemId",0); SWIG_RegisterMapping("_unsigned_char","_byte",0); @@ -1998,6 +2163,7 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0); SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0); SWIG_RegisterMapping("_class_wxNotebook","_wxNotebook",0); + SWIG_RegisterMapping("_wxJPEGHandler","_class_wxJPEGHandler",0); SWIG_RegisterMapping("_wxWindowID","_EBool",0); SWIG_RegisterMapping("_wxWindowID","_uint",0); SWIG_RegisterMapping("_wxWindowID","_int",0); @@ -2017,6 +2183,7 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0); SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",0); SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0); + SWIG_RegisterMapping("_wxPyTreeItemData","_class_wxPyTreeItemData",0); SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0); SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0); SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0); @@ -2049,7 +2216,6 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0); SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0); SWIG_RegisterMapping("_class_wxListCtrl","_wxListCtrl",0); - SWIG_RegisterMapping("_class_wxTreeItemData","_wxTreeItemData",0); SWIG_RegisterMapping("_class_wxGridCell","_wxGridCell",0); SWIG_RegisterMapping("_class_wxSize","_wxSize",0); SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0); @@ -2063,15 +2229,14 @@ SWIGEXPORT(void,initwxc)() { SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0); SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0); SWIG_RegisterMapping("_class_wxColourDialog","_wxColourDialog",0); - SWIG_RegisterMapping("_class_wxPrintData","_wxPrintData",0); SWIG_RegisterMapping("_wxDash","_unsigned_long",0); SWIG_RegisterMapping("_wxDash","_long",0); SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0); SWIG_RegisterMapping("_class_wxTextEntryDialog","_wxTextEntryDialog",0); - SWIG_RegisterMapping("_class_wxConfig","_wxConfig",0); SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0); SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0); SWIG_RegisterMapping("_wxColourData","_class_wxColourData",0); + SWIG_RegisterMapping("_wxPageSetupDialogData","_class_wxPageSetupDialogData",0); SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0); SWIG_RegisterMapping("_class_wxQueryLayoutInfoEvent","_wxQueryLayoutInfoEvent",0); SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0); diff --git a/utils/wxPython/src/msw/wx.py b/utils/wxPython/src/msw/wx.py index 623173aeb7..9910e29cbf 100644 --- a/utils/wxPython/src/msw/wx.py +++ b/utils/wxPython/src/msw/wx.py @@ -25,7 +25,7 @@ from cmndlgs import * from windows3 import * -from utils import * +from image import * class wxPyAppPtr(wxEvtHandlerPtr): def __init__(self,this): self.this = this @@ -203,6 +203,7 @@ wxSL_BOTH = wxc.wxSL_BOTH wxSL_SELRANGE = wxc.wxSL_SELRANGE wxSB_HORIZONTAL = wxc.wxSB_HORIZONTAL wxSB_VERTICAL = wxc.wxSB_VERTICAL +wxST_SIZEGRIP = wxc.wxST_SIZEGRIP wxBU_AUTODRAW = wxc.wxBU_AUTODRAW wxBU_NOAUTODRAW = wxc.wxBU_NOAUTODRAW wxTR_HAS_BUTTONS = wxc.wxTR_HAS_BUTTONS @@ -232,10 +233,6 @@ wxSP_WRAP = wxc.wxSP_WRAP wxSP_NOBORDER = wxc.wxSP_NOBORDER wxSP_3D = wxc.wxSP_3D wxSP_BORDER = wxc.wxSP_BORDER -wxTAB_MULTILINE = wxc.wxTAB_MULTILINE -wxTAB_RIGHTJUSTIFY = wxc.wxTAB_RIGHTJUSTIFY -wxTAB_FIXEDWIDTH = wxc.wxTAB_FIXEDWIDTH -wxTAB_OWNERDRAW = wxc.wxTAB_OWNERDRAW wxFLOOD_SURFACE = wxc.wxFLOOD_SURFACE wxFLOOD_BORDER = wxc.wxFLOOD_BORDER wxODDEVEN_RULE = wxc.wxODDEVEN_RULE @@ -308,6 +305,7 @@ wxID_CANCEL = wxc.wxID_CANCEL wxID_APPLY = wxc.wxID_APPLY wxID_YES = wxc.wxID_YES wxID_NO = wxc.wxID_NO +wxID_STATIC = wxc.wxID_STATIC wxBITMAP_TYPE_BMP = wxc.wxBITMAP_TYPE_BMP wxBITMAP_TYPE_BMP_RESOURCE = wxc.wxBITMAP_TYPE_BMP_RESOURCE wxBITMAP_TYPE_ICO = wxc.wxBITMAP_TYPE_ICO @@ -326,6 +324,7 @@ wxBITMAP_TYPE_PNG = wxc.wxBITMAP_TYPE_PNG wxBITMAP_TYPE_PNG_RESOURCE = wxc.wxBITMAP_TYPE_PNG_RESOURCE wxBITMAP_TYPE_ANY = wxc.wxBITMAP_TYPE_ANY wxBITMAP_TYPE_RESOURCE = wxc.wxBITMAP_TYPE_RESOURCE +wxBITMAP_TYPE_JPEG = wxc.wxBITMAP_TYPE_JPEG wxOPEN = wxc.wxOPEN wxSAVE = wxc.wxSAVE wxHIDE_READONLY = wxc.wxHIDE_READONLY @@ -333,10 +332,6 @@ wxOVERWRITE_PROMPT = wxc.wxOVERWRITE_PROMPT wxACCEL_ALT = wxc.wxACCEL_ALT wxACCEL_CTRL = wxc.wxACCEL_CTRL wxACCEL_SHIFT = wxc.wxACCEL_SHIFT -ERR_PARAM = wxc.ERR_PARAM -ERR_NODATA = wxc.ERR_NODATA -ERR_CANCEL = wxc.ERR_CANCEL -ERR_SUCCESS = wxc.ERR_SUCCESS wxDEFAULT = wxc.wxDEFAULT wxDECORATIVE = wxc.wxDECORATIVE wxROMAN = wxc.wxROMAN @@ -490,6 +485,73 @@ wxCURSOR_SPRAYCAN = wxc.wxCURSOR_SPRAYCAN wxCURSOR_WAIT = wxc.wxCURSOR_WAIT wxCURSOR_WATCH = wxc.wxCURSOR_WATCH wxCURSOR_BLANK = wxc.wxCURSOR_BLANK +wxPAPER_NONE = wxc.wxPAPER_NONE +wxPAPER_LETTER = wxc.wxPAPER_LETTER +wxPAPER_LEGAL = wxc.wxPAPER_LEGAL +wxPAPER_A4 = wxc.wxPAPER_A4 +wxPAPER_CSHEET = wxc.wxPAPER_CSHEET +wxPAPER_DSHEET = wxc.wxPAPER_DSHEET +wxPAPER_ESHEET = wxc.wxPAPER_ESHEET +wxPAPER_LETTERSMALL = wxc.wxPAPER_LETTERSMALL +wxPAPER_TABLOID = wxc.wxPAPER_TABLOID +wxPAPER_LEDGER = wxc.wxPAPER_LEDGER +wxPAPER_STATEMENT = wxc.wxPAPER_STATEMENT +wxPAPER_EXECUTIVE = wxc.wxPAPER_EXECUTIVE +wxPAPER_A3 = wxc.wxPAPER_A3 +wxPAPER_A4SMALL = wxc.wxPAPER_A4SMALL +wxPAPER_A5 = wxc.wxPAPER_A5 +wxPAPER_B4 = wxc.wxPAPER_B4 +wxPAPER_B5 = wxc.wxPAPER_B5 +wxPAPER_FOLIO = wxc.wxPAPER_FOLIO +wxPAPER_QUARTO = wxc.wxPAPER_QUARTO +wxPAPER_10X14 = wxc.wxPAPER_10X14 +wxPAPER_11X17 = wxc.wxPAPER_11X17 +wxPAPER_NOTE = wxc.wxPAPER_NOTE +wxPAPER_ENV_9 = wxc.wxPAPER_ENV_9 +wxPAPER_ENV_10 = wxc.wxPAPER_ENV_10 +wxPAPER_ENV_11 = wxc.wxPAPER_ENV_11 +wxPAPER_ENV_12 = wxc.wxPAPER_ENV_12 +wxPAPER_ENV_14 = wxc.wxPAPER_ENV_14 +wxPAPER_ENV_DL = wxc.wxPAPER_ENV_DL +wxPAPER_ENV_C5 = wxc.wxPAPER_ENV_C5 +wxPAPER_ENV_C3 = wxc.wxPAPER_ENV_C3 +wxPAPER_ENV_C4 = wxc.wxPAPER_ENV_C4 +wxPAPER_ENV_C6 = wxc.wxPAPER_ENV_C6 +wxPAPER_ENV_C65 = wxc.wxPAPER_ENV_C65 +wxPAPER_ENV_B4 = wxc.wxPAPER_ENV_B4 +wxPAPER_ENV_B5 = wxc.wxPAPER_ENV_B5 +wxPAPER_ENV_B6 = wxc.wxPAPER_ENV_B6 +wxPAPER_ENV_ITALY = wxc.wxPAPER_ENV_ITALY +wxPAPER_ENV_MONARCH = wxc.wxPAPER_ENV_MONARCH +wxPAPER_ENV_PERSONAL = wxc.wxPAPER_ENV_PERSONAL +wxPAPER_FANFOLD_US = wxc.wxPAPER_FANFOLD_US +wxPAPER_FANFOLD_STD_GERMAN = wxc.wxPAPER_FANFOLD_STD_GERMAN +wxPAPER_FANFOLD_LGL_GERMAN = wxc.wxPAPER_FANFOLD_LGL_GERMAN +wxPAPER_ISO_B4 = wxc.wxPAPER_ISO_B4 +wxPAPER_JAPANESE_POSTCARD = wxc.wxPAPER_JAPANESE_POSTCARD +wxPAPER_9X11 = wxc.wxPAPER_9X11 +wxPAPER_10X11 = wxc.wxPAPER_10X11 +wxPAPER_15X11 = wxc.wxPAPER_15X11 +wxPAPER_ENV_INVITE = wxc.wxPAPER_ENV_INVITE +wxPAPER_LETTER_EXTRA = wxc.wxPAPER_LETTER_EXTRA +wxPAPER_LEGAL_EXTRA = wxc.wxPAPER_LEGAL_EXTRA +wxPAPER_TABLOID_EXTRA = wxc.wxPAPER_TABLOID_EXTRA +wxPAPER_A4_EXTRA = wxc.wxPAPER_A4_EXTRA +wxPAPER_LETTER_TRANSVERSE = wxc.wxPAPER_LETTER_TRANSVERSE +wxPAPER_A4_TRANSVERSE = wxc.wxPAPER_A4_TRANSVERSE +wxPAPER_LETTER_EXTRA_TRANSVERSE = wxc.wxPAPER_LETTER_EXTRA_TRANSVERSE +wxPAPER_A_PLUS = wxc.wxPAPER_A_PLUS +wxPAPER_B_PLUS = wxc.wxPAPER_B_PLUS +wxPAPER_LETTER_PLUS = wxc.wxPAPER_LETTER_PLUS +wxPAPER_A4_PLUS = wxc.wxPAPER_A4_PLUS +wxPAPER_A5_TRANSVERSE = wxc.wxPAPER_A5_TRANSVERSE +wxPAPER_B5_TRANSVERSE = wxc.wxPAPER_B5_TRANSVERSE +wxPAPER_A3_EXTRA = wxc.wxPAPER_A3_EXTRA +wxPAPER_A5_EXTRA = wxc.wxPAPER_A5_EXTRA +wxPAPER_B5_EXTRA = wxc.wxPAPER_B5_EXTRA +wxPAPER_A2 = wxc.wxPAPER_A2 +wxPAPER_A3_TRANSVERSE = wxc.wxPAPER_A3_TRANSVERSE +wxPAPER_A3_EXTRA_TRANSVERSE = wxc.wxPAPER_A3_EXTRA_TRANSVERSE FALSE = wxc.FALSE false = wxc.false TRUE = wxc.TRUE @@ -672,8 +734,9 @@ def _StdWindowCallbacks(win): _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) + _checkForCallback(win, "OnIdle", wxEVT_IDLE) + def _StdFrameCallbacks(win): _StdWindowCallbacks(win) @@ -691,7 +754,7 @@ def _StdDialogCallbacks(win): _checkForCallback(win, "OnCharHook", wxEVT_CHAR_HOOK) -def _StdOnScrollCallback(win): +def _StdOnScrollCallbacks(win): try: cb = getattr(win, "OnScroll") except: pass else: EVT_SCROLL(win, cb) @@ -770,6 +833,9 @@ def EVT_ICONIZE(win, func): def EVT_NAVIGATION_KEY(win, func): win.Connect(-1, -1, wxEVT_NAVIGATION_KEY, func) +def EVT_IDLE(win, func): + win.Connect(-1, -1, wxEVT_IDLE, func) + # Mouse Events def EVT_LEFT_DOWN(win, func): @@ -1196,27 +1262,32 @@ class wxAcceleratorTable(wxAcceleratorTablePtr): #---------------------------------------------------------------------- -## 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 +## class wxPyStdOutWindow: +## def __init__(self, title = "wxPython: stdout/stderr"): +## self.frame = None +## self.title = title -## def write(self, str): # with this method, -## if not self.isShown: -## self.Show(true) -## self.isShown = true -## self.text.WriteText(str) +## def write(self, str): +## if not self.frame: +## self.frame = wxFrame(NULL, -1, self.title) +## self.text = wxTextCtrl(self.frame, -1, "", wxPoint(0,0), wxDefaultSize, +## wxTE_MULTILINE|wxTE_READONLY) +## self.frame.SetSize(wxSize(450, 300)) +## self.frame.Show(true) +## EVT_CLOSE(self.frame, self.OnCloseWindow) +## self.text.AppendText(str) -## def OnCloseWindow(self, event): # doesn't allow the window to close, just hides it -## self.Show(false) -## self.isShown = false +## def OnCloseWindow(self, event): +## wxBell() +## self.frame.Destroy() +## self.frame = None +## self.text = None +## def close(self): +## if self.frame: +## self.frame.Close(true) + _defRedirect = (wxPlatform == '__WXMSW__') #---------------------------------------------------------------------- @@ -1247,22 +1318,35 @@ class wxApp(wxPyApp): if filename: sys.stdout = sys.stderr = open(filename, 'a') else: - raise self.error, 'wxPyStdOutWindow not yet implemented.' - #self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow() + #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 + self.stdioWin.close() #---------------------------------------------------------------------------- # # $Log$ -# Revision 1.8 1999/03/05 07:23:07 RD -# Minor wxPython changes for wxWin 2.0 +# Revision 1.9 1999/04/30 03:29:48 RD +# wxPython 2.0b9, first phase (win32) +# Added gobs of stuff, see wxPython/README.txt for details +# +# Revision 1.11.4.2 1999/03/28 06:35:01 RD +# +# wxPython 2.0b8 +# Python thread support +# various minor additions +# various minor fixes +# +# Revision 1.11.4.1 1999/03/27 23:29:13 RD +# +# wxPython 2.0b8 +# Python thread support +# various minor additions +# various minor fixes # # Revision 1.11 1999/02/20 09:02:55 RD # Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a diff --git a/utils/wxPython/src/my_typemaps.i b/utils/wxPython/src/my_typemaps.i index 475903f3f3..20d43b33fb 100644 --- a/utils/wxPython/src/my_typemaps.i +++ b/utils/wxPython/src/my_typemaps.i @@ -11,6 +11,15 @@ ///////////////////////////////////////////////////////////////////////////// +//--------------------------------------------------------------------------- +// Tell SWIG to wrap all the wrappers with Python's thread macros + +%except(python) { + wxPy_BEGIN_ALLOW_THREADS; + $function + wxPy_END_ALLOW_THREADS; +} + //---------------------------------------------------------------------- // Here are some to map (int LCOUNT, int* LIST), etc. from a python list @@ -30,7 +39,12 @@ extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source); //---------------------------------------------------------------------- %typemap(python,build) int LCOUNT { - $target = PyList_Size(_in_LIST); + if (_in_LIST) { + $target = PyList_Size(_in_LIST); + } + else { + $target = 0; + } } @@ -148,7 +162,7 @@ static char* wxStringErrorMsg = "string type is required for parameter"; PyErr_SetString(PyExc_TypeError, wxStringErrorMsg); return NULL; } - $target = new wxString(PyString_AsString($source)); + $target = new wxString(PyString_AsString($source), PyString_Size($source)); } %typemap(python, freearg) wxString& { if ($target) @@ -198,7 +212,23 @@ static char* wxStringErrorMsg = "string type is required for parameter"; ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.5 1999/04/30 03:29:19 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.4.4.2 1999/03/28 06:35:01 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// +// Revision 1.4.4.1 1999/03/16 06:04:03 RD +// +// wxPython 2.0b7 +// // Revision 1.4 1998/11/25 08:45:27 RD +// // Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon // Added events for wxGrid // Other various fixes and additions diff --git a/utils/wxPython/src/utils.i b/utils/wxPython/src/utils.i index a2b94ff28c..f10d2f7506 100644 --- a/utils/wxPython/src/utils.i +++ b/utils/wxPython/src/utils.i @@ -1,6 +1,6 @@ ///////////////////////////////////////////////////////////////////////////// // Name: utils.i -// Purpose: SWIG definitions of various utility classes classes +// Purpose: SWIG definitions of various utility classes // // Author: Robin Dunn // @@ -54,11 +54,6 @@ public: long style = 0); ~wxConfig(); - //static wxConfigBase * Create(); - //static wxConfigBase * Get(); - //static wxConfigBase * Set(wxConfigBase *pConfig); - - void DontCreateOnDemand(); bool DeleteAll(); // This is supposed to have been fixed... @@ -121,11 +116,9 @@ public: %name(ReadInt)long Read(const wxString& key, long defaultVal = 0); %name(ReadFloat)double Read(const wxString& key, double defaultVal = 0.0); - void SetAppName(const wxString& appName); void SetExpandEnvVars (bool bDoIt = TRUE); void SetPath(const wxString& strPath); void SetRecordDefaults(bool bDoIt = TRUE); - void SetVendorName(const wxString& vendorName); bool Write(const wxString& key, const wxString& value); %name(WriteInt)bool Write(const wxString& key, long value); @@ -138,7 +131,19 @@ public: ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.4 1999/04/30 03:29:19 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.3.4.1 1999/03/27 23:29:15 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// // Revision 1.3 1999/02/25 07:08:36 RD +// // wxPython version 2.0b5 // // Revision 1.2 1999/02/20 09:03:02 RD diff --git a/utils/wxPython/src/windows.i b/utils/wxPython/src/windows.i index 8243a53ec4..99fc69c14d 100644 --- a/utils/wxPython/src/windows.i +++ b/utils/wxPython/src/windows.i @@ -34,6 +34,7 @@ class wxEvtHandler { public: + bool ProcessEvent(wxEvent& event); %addmethods { void Connect( int id, int lastId, int eventType, PyObject* func) { if (PyCallable_Check(func)) { @@ -176,6 +177,9 @@ public: %name(ConvertDialogPointToPixels) wxPoint ConvertDialogToPixels(const wxPoint& pt); %name(ConvertDialogSizeToPixels) wxSize ConvertDialogToPixels(const wxSize& sz); + %name(DLG_PNT) wxPoint ConvertDialogToPixels(const wxPoint& pt); + %name(DLG_SZE) wxSize ConvertDialogToPixels(const wxSize& sz); + %name(ConvertPixelPointToDialog) wxPoint ConvertPixelsToDialog(const wxPoint& pt); %name(ConvertPixelSizeToDialog) wxSize ConvertPixelsToDialog(const wxSize& sz); @@ -354,6 +358,15 @@ public: class wxMenuItem { public: +#ifndef __WXGTK__ + wxMenuItem(wxMenu* parentMenu=NULL, int id=ID_SEPARATOR, + const wxString& text = wxPyEmptyStr, + const wxString& helpString = wxPyEmptyStr, + bool checkable = FALSE, wxMenu* subMenu = NULL); +#else + wxMenuItem(); +#endif + bool IsSeparator(); bool IsEnabled(); bool IsChecked(); @@ -361,13 +374,23 @@ public: int GetId(); wxMenu* GetSubMenu(); void SetName(const wxString& strName); - const wxString& GetName(); - const wxString& GetHelp(); + wxString GetName(); + wxString GetHelp(); void SetHelp(const wxString& strHelp); void Enable(bool bDoEnable = TRUE); void Check(bool bDoCheck = TRUE); #ifdef __WXMSW__ + wxColour& GetBackgroundColour(); + wxBitmap GetBitmap(bool checked = TRUE); + wxFont& GetFont(); + int GetMarginWidth(); + wxColour& GetTextColour(); + void SetBackgroundColour(const wxColour& colour); + void SetBitmaps(const wxBitmap& checked, const wxBitmap& unchecked = wxNullBitmap); + void SetFont(const wxFont& font); + void SetMarginWidth(int width); + void SetTextColour(const wxColour& colour); void DeleteSubMenu(); #endif }; @@ -376,7 +399,27 @@ public: ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.15 1999/04/30 03:29:19 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.14.4.3 1999/03/27 23:29:15 RD +// +// wxPython 2.0b8 +// Python thread support +// various minor additions +// various minor fixes +// +// Revision 1.14.4.2 1999/03/16 06:26:29 RD +// +// wxPython 2.0b7 +// +// Revision 1.14.4.1 1999/03/16 06:04:04 RD +// +// wxPython 2.0b7 +// // Revision 1.14 1999/02/23 23:48:33 RD +// // reenabled some methods for wxPython on wxGTK // // Revision 1.13 1999/02/20 10:02:38 RD diff --git a/utils/wxPython/src/windows2.i b/utils/wxPython/src/windows2.i index 63a0b08739..ca69b282b3 100644 --- a/utils/wxPython/src/windows2.i +++ b/utils/wxPython/src/windows2.i @@ -128,7 +128,7 @@ public: wxString& GetCellValue(int row, int col); int GetCols(); int GetColumnWidth(int col); - wxRect& GetCurrentRect(); + wxRect GetCurrentRect(); int GetCursorColumn(); int GetCursorRow(); bool GetEditable(); @@ -238,10 +238,11 @@ public: // LINK ERROR: void SetPageSize(const wxSize& size); // LINK ERROR: void SetPadding(const wxSize& padding); bool DeletePage(int nPage); + bool RemovePage(int nPage); bool DeleteAllPages(); bool AddPage(/*wxNotebookPage*/ wxWindow *pPage, const wxString& strText, - bool bSelect = FALSE, + int bSelect = FALSE, int imageId = -1); #ifdef __WXMSW__ bool InsertPage(int nPage, @@ -252,6 +253,14 @@ public: #endif wxNotebookPage *GetPage(int nPage); + %addmethods { + void ResizeChildren() { + wxSizeEvent evt(self->GetClientSize()); + self->OnSize(evt); + } + } + + }; //--------------------------------------------------------------------------- @@ -332,7 +341,16 @@ public: ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.10 1999/04/30 03:29:19 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// +// Revision 1.9.4.1 1999/03/16 06:04:05 RD +// +// wxPython 2.0b7 +// // Revision 1.9 1999/02/25 07:08:36 RD +// // wxPython version 2.0b5 // // Revision 1.8 1998/12/17 18:05:53 RD diff --git a/utils/wxPython/src/windows3.i b/utils/wxPython/src/windows3.i index c8c038a440..64934638e7 100644 --- a/utils/wxPython/src/windows3.i +++ b/utils/wxPython/src/windows3.i @@ -176,6 +176,7 @@ public: bool LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* rect = NULL); bool LayoutFrame(wxFrame* frame, wxWindow* mainWindow = NULL); + bool LayoutWindow(wxWindow* parent, wxWindow* mainWindow = NULL); }; @@ -183,7 +184,12 @@ public: ///////////////////////////////////////////////////////////////////////////// // // $Log$ +// Revision 1.2 1999/04/30 03:29:19 RD +// wxPython 2.0b9, first phase (win32) +// Added gobs of stuff, see wxPython/README.txt for details +// // Revision 1.1 1999/01/30 07:30:16 RD +// // Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc. // // Various cleanup, tweaks, minor additions, etc. to maintain diff --git a/utils/wxPython/src/wx.i b/utils/wxPython/src/wx.i index a0e23c1149..a3c7d06b4c 100644 --- a/utils/wxPython/src/wx.i +++ b/utils/wxPython/src/wx.i @@ -37,9 +37,7 @@ %import stattool.i %import frames.i %import windows3.i -#ifndef SEPARATE -%import utils.i -#endif +%import image.i %native(_wxStart) __wxStart; @@ -47,7 +45,7 @@ //--------------------------------------------------------------------------- -#define __version__ "2.0b6" +#define __version__ "2.0b9" wxPoint wxPyDefaultPosition; wxSize wxPyDefaultSize; @@ -115,8 +113,10 @@ extern "C" SWIGEXPORT(void,initcmndlgsc)(); extern "C" SWIGEXPORT(void,initstattoolc)(); extern "C" SWIGEXPORT(void,initframesc)(); extern "C" SWIGEXPORT(void,initwindows3c)(); +extern "C" SWIGEXPORT(void,initimagec)(); #ifndef SEPARATE extern "C" SWIGEXPORT(void,initutilsc)(); +extern "C" SWIGEXPORT(void,initglcanvasc)(); #endif %} @@ -143,8 +143,12 @@ extern "C" SWIGEXPORT(void,initutilsc)(); initstattoolc(); initframesc(); initwindows3c(); + initimagec(); #ifndef SEPARATE initutilsc(); +#ifdef WITH_GLCANVAS + initglcanvasc(); +#endif #endif %} @@ -155,103 +159,3 @@ extern "C" SWIGEXPORT(void,initutilsc)(); %pragma(python) include="_extras.py"; -///////////////////////////////////////////////////////////////////////////// -// -// $Log$ -// Revision 1.8 1999/03/05 07:22:32 RD -// Minor wxPython changes for wxWin 2.0 -// -// Revision 1.7 1999/02/25 07:08:37 RD -// -// wxPython version 2.0b5 -// -// Revision 1.6 1999/02/20 09:03:04 RD -// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a -// window handle. If you can get the window handle into the python code, -// it should just work... More news on this later. -// -// Added wxImageList, wxToolTip. -// -// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the -// wxRegConfig class. -// -// As usual, some bug fixes, tweaks, etc. -// -// Revision 1.5 1999/02/01 00:10:41 RD -// -// Added the missing EVT_LIST_ITEM_SELECTED and friends. -// -// Revision 1.4 1999/01/30 07:30:16 RD -// -// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc. -// -// Various cleanup, tweaks, minor additions, etc. to maintain -// compatibility with the current wxWindows. -// -// Revision 1.3 1998/12/17 17:52:21 RD -// -// wxPython 0.5.2 -// Minor fixes and SWIG code generation for RR's changes. MSW and GTK -// versions are much closer now! -// -// Revision 1.2 1998/12/16 22:10:57 RD -// -// Tweaks needed to be able to build wxPython with wxGTK. -// -// Revision 1.1 1998/12/15 20:41:27 RD -// Changed the import semantics from "from wxPython import *" to "from -// wxPython.wx import *" This is for people who are worried about -// namespace pollution, they can use "from wxPython import wx" and then -// prefix all the wxPython identifiers with "wx." -// -// Added wxTaskbarIcon for wxMSW. -// -// Made the events work for wxGrid. -// -// Added wxConfig. -// -// Added wxMiniFrame for wxGTK, (untested.) -// -// Changed many of the args and return values that were pointers to gdi -// objects to references to reflect changes in the wxWindows API. -// -// Other assorted fixes and additions. -// -// Revision 1.9 1998/10/20 07:38:04 RD -// bug fix -// -// Revision 1.8 1998/10/07 07:34:35 RD -// Version 0.4.1 for wxGTK -// -// Revision 1.7 1998/10/02 06:40:44 RD -// -// Version 0.4 of wxPython for MSW. -// -// Revision 1.6 1998/08/27 21:59:10 RD -// Some chicken-and-egg problems solved for wxPython on wxGTK -// -// Revision 1.5 1998/08/27 00:00:28 RD -// - more tweaks -// - have discovered some problems but not yet discovered solutions... -// -// Revision 1.4 1998/08/18 19:48:20 RD -// more wxGTK compatibility things. -// -// It builds now but there are serious runtime problems... -// -// Revision 1.3 1998/08/15 07:36:53 RD -// - Moved the header in the .i files out of the code that gets put into -// the .cpp files. It caused CVS conflicts because of the RCS ID being -// different each time. -// -// - A few minor fixes. -// -// Revision 1.2 1998/08/14 23:36:49 RD -// Beginings of wxGTK compatibility -// -// Revision 1.1 1998/08/09 08:25:53 RD -// Initial version -// -// - - diff --git a/utils/wxPython/src/wxc.def b/utils/wxPython/src/wxc.def index 0cde9c79c3..87d2d233b6 100644 --- a/utils/wxPython/src/wxc.def +++ b/utils/wxPython/src/wxc.def @@ -1,2 +1,6 @@ EXPORTS initwxc + SWIG_GetPtr + SWIG_MakePtr + SWIG_RegisterMapping + SWIG_newvarlink diff --git a/utils/wxPython/tests/test1.py b/utils/wxPython/tests/test1.py index d423811d90..90e68ee2de 100644 --- a/utils/wxPython/tests/test1.py +++ b/utils/wxPython/tests/test1.py @@ -76,6 +76,7 @@ class MyApp(wxApp): app = MyApp(0) # Create an instance of the application class app.MainLoop() # Tell it to start processing events +print 'done!' #---------------------------------------------------------------------------- # diff --git a/utils/wxPython/tests/test2.py b/utils/wxPython/tests/test2.py index bca6b1ae0a..aacfba61e7 100644 --- a/utils/wxPython/tests/test2.py +++ b/utils/wxPython/tests/test2.py @@ -19,9 +19,9 @@ from wxPython.wx import * -class MyCanvas(wxWindow): +class MyCanvas(wxScrolledWindow): def __init__(self, parent): - wxWindow.__init__(self, parent, -1, wxPoint(0, 0), wxPyDefaultSize, wxSUNKEN_BORDER) + wxScrolledWindow.__init__(self, parent, -1, wxPoint(0, 0), wxPyDefaultSize, wxSUNKEN_BORDER) self.SetBackgroundColour(wxNamedColor("WHITE")) self.Connect(-1, -1, wxEVT_LEFT_DOWN, self.OnLeftButtonEvent) @@ -30,16 +30,17 @@ class MyCanvas(wxWindow): 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.SetScrollbars(20, 20, 50, 50) + self.lines = [] def OnPaint(self, event): dc = wxPaintDC(self) + self.PrepareDC(dc) self.DoDrawing(dc) @@ -133,6 +134,7 @@ class MyApp(wxApp): self.SetTopWindow(frame) return true + #--------------------------------------------------------------------------- @@ -152,6 +154,17 @@ if __name__ == '__main__': #---------------------------------------------------------------------------- # # $Log$ +# Revision 1.3 1999/04/30 03:29:53 RD +# wxPython 2.0b9, first phase (win32) +# Added gobs of stuff, see wxPython/README.txt for details +# +# Revision 1.2.4.1 1999/03/27 23:30:00 RD +# +# wxPython 2.0b8 +# Python thread support +# various minor additions +# various minor fixes +# # Revision 1.2 1998/12/15 20:44:34 RD # Changed the import semantics from "from wxPython import *" to "from # wxPython.wx import *" This is for people who are worried about diff --git a/utils/wxPython/tests/test3.py b/utils/wxPython/tests/test3.py index 64a11120cc..da57af5baa 100644 --- a/utils/wxPython/tests/test3.py +++ b/utils/wxPython/tests/test3.py @@ -50,7 +50,6 @@ class MyMiniFrame(wxMiniFrame): def OnCloseWindow(self, event): self.Destroy() - #--------------------------------------------------------------------------- class MyFrame(wxFrame): @@ -147,6 +146,10 @@ if __name__ == '__main__': #---------------------------------------------------------------------------- # # $Log$ +# Revision 1.6 1999/04/30 03:29:53 RD +# wxPython 2.0b9, first phase (win32) +# Added gobs of stuff, see wxPython/README.txt for details +# # Revision 1.5 1999/02/20 09:04:43 RD # Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a # window handle. If you can get the window handle into the python code, diff --git a/utils/wxPython/tests/test4.py b/utils/wxPython/tests/test4.py index 2370a498ba..89b94ebe2e 100644 --- a/utils/wxPython/tests/test4.py +++ b/utils/wxPython/tests/test4.py @@ -22,7 +22,7 @@ class TestSimpleControlsDlg(wxDialog): def __init__(self, parent, log): self.log = log wxDialog.__init__(self, parent, -1, "Test Simple Controls", - wxDefaultPosition, wxSize(350, 350)) + wxDefaultPosition, wxSize(350, 400)) sampleList = ["zero", "one", "two", "three", "four", "five", @@ -250,10 +250,9 @@ class ColoredPanel(wxWindow): class TestNotebookWindow(wxFrame): def __init__(self, parent, log): - wxFrame.__init__(self, parent, -1, 'Test wxNotebook', - wxDefaultPosition, wxDefaultSize) + wxFrame.__init__(self, parent, -1, 'Test wxNotebook') - nb = wxNotebook(self, -1) + nb = wxNotebook(self, -1, wxPoint(0,0), self.GetClientSize()) win = ColoredPanel(nb, wxBLUE) nb.AddPage(win, "Blue") @@ -295,9 +294,8 @@ class TestNotebookWindow(wxFrame): win = ColoredPanel(nb, wxNamedColour('INDIAN RED')) nb.AddPage(win, "INDIAN RED") - nb.SetSelection(0) - self.SetSize(wxSize(350, 300)) # force a redraw so the notebook will draw + self.SetSize(wxSize(350, 300)) def OnCloseWindow(self, event): @@ -518,8 +516,8 @@ class TestListCtrlPanel(wxPanel): wxLC_REPORT|wxSUNKEN_BORDER) self.list.SetImageList(self.il, wxIMAGE_LIST_SMALL) - self.list.SetToolTip(wxToolTip("This is a ToolTip!")) - wxToolTip_Enable(true) + #self.list.SetToolTip(wxToolTip("This is a ToolTip!")) + #wxToolTip_Enable(true) self.list.InsertColumn(0, "Column 0") self.list.InsertColumn(1, "Column 1") @@ -896,7 +894,7 @@ class AppFrame(wxFrame): def OnTestPageSetupDlg(self, event): - data = wxPageSetupData() + data = wxPageSetupDialogData() data.SetMarginTopLeft(wxPoint(50,50)) data.SetMarginBottomRight(wxPoint(50,50)) dlg = wxPageSetupDialog(self, data) @@ -908,7 +906,7 @@ class AppFrame(wxFrame): dlg.Destroy() def OnTestPrintDlg(self, event): - data = wxPrintData() + data = wxPrintDialogData() data.EnablePrintToFile(true) data.EnablePageNumbers(true) data.EnableSelection(true) @@ -1000,7 +998,16 @@ if __name__ == '__main__': #---------------------------------------------------------------------------- # # $Log$ +# Revision 1.16 1999/04/30 03:29:54 RD +# wxPython 2.0b9, first phase (win32) +# Added gobs of stuff, see wxPython/README.txt for details +# +# Revision 1.15.2.1 1999/03/16 06:05:50 RD +# +# wxPython 2.0b7 +# # Revision 1.15 1999/03/05 07:23:42 RD +# # Minor wxPython changes for wxWin 2.0 # # Revision 1.14 1999/02/27 04:20:50 RD diff --git a/utils/wxPython/tests/test4s.py b/utils/wxPython/tests/test4s.py deleted file mode 100644 index 531fea7030..0000000000 --- a/utils/wxPython/tests/test4s.py +++ /dev/null @@ -1,18 +0,0 @@ -#!/bin/env python -#---------------------------------------------------------------------------- -# Name: test4s.py -# Purpose: Stub for test4. Speeds startup time by using compiled version -# of test4.py. -# -# Author: Robin Dunn -# -# Created: -# RCS-ID: $Id$ -# Copyright: (c) 1998 by Total Control Software -# Licence: wxWindows license -#---------------------------------------------------------------------------- - - -import test4 - -test4.main() diff --git a/utils/wxPython/tests/test8.py b/utils/wxPython/tests/test8.py new file mode 100644 index 0000000000..ec383b7a09 --- /dev/null +++ b/utils/wxPython/tests/test8.py @@ -0,0 +1,85 @@ +# Thread testing example. Harm van der Heijden, March 26 1999. +# +# Rule One in threading: make sure only one thread interacts with the +# user interface. See the wxTextCtrlQueue class for an example of how +# to accomplish this + +import thread +import time +from whrandom import random + +from wxPython.wx import * + +# Set this to zero to prevent entering the wxApp mainloop +# (for testing whether threads work at all in the absense of wxWindows) +use_wxpython = 1 + +# write a message to stdout every second +def DoThread(mesg): + while 1: + sleeptime = (random() * 3) + 0.5 + print "Hello from %s (%1.3f)" % (mesg, sleeptime) + time.sleep(sleeptime) + +# the same, but write it to a textctrl. +def DoTextCtrlThread(text, mesg): + while 1: + sleeptime = (random() * 3) + 0.5 + text.WriteText("Hello from %s (%1.3f)\n" % (mesg, sleeptime)) + time.sleep(sleeptime) + +# A very simple queue for textctrls. +# Nice demonstration of the power of OO programming too (at least I think so!) +# WriteText puts text in the queue, rather than writing it immediately. +# The main (UI) thread must call Flush to force output. (see MyFrame::OnIdle) +class wxTextCtrlQueue(wxTextCtrl): + def __init__(self, parent, id, value, pos, size, flags): + wxTextCtrl.__init__(self,parent, id, value, pos, size, flags) + self.queue = [] + def WriteText(self, value): + self.queue.append(value) + def Flush(self): + queue = self.queue + self.queue = [] + for value in queue: + wxTextCtrl.WriteText(self,value) + +# MyFrame and MyApp are very simple classes to test python threads in +# wxPython. +class MyFrame(wxFrame): + def __init__(self): + wxFrame.__init__(self, NULL, -1, "test threads", wxDefaultPosition, wxSize(300,200)) + self.text = wxTextCtrlQueue(self, -1, "thread output\n", wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE) + menu = wxMenu() + menu.Append(1001, "Start thread") + self.cnt = 0; + menubar = wxMenuBar() + menubar.Append(menu, "Action") + self.SetMenuBar(menubar) + EVT_MENU(self, 1001, self.StartThread) + def StartThread(self, event): + self.cnt = self.cnt + 1 + thread.start_new_thread(DoTextCtrlThread, (self.text, "thread %d" % self.cnt)) + def OnIdle(self, event): + self.text.Flush() + +class MyApp(wxApp): + def OnInit(self): + frame = MyFrame() + self.SetTopWindow(frame) + frame.Show(TRUE) + return TRUE + +# Start two threads that print a message every second +thread.start_new_thread(DoThread, ("thread A",)) +thread.start_new_thread(DoThread, ("thread B",)) + +# if using wxpython, open a frame. Otherwise, just hang in while 1 +if use_wxpython: + app = MyApp(0) + app.MainLoop() +else: + while 1: + print "main loop" + time.sleep(4) +print 'done!'