----------------------------------------------------------------------
-What's new in 2.1b4
+
+What's new in 2.1.4
--------------------
-Much more support for event-less callbacks and add-on modules
+Much more support for event-less callbacks and add-on modules.
Created add-on module with wxOGL classes.
-Added wxWindow.GetChildren(). Be careful of this. It returns a copy
+Added wxWindow.GetChildren(). Be careful of this. It returns a *copy*
of the list of the window's children. While you are using the list if
anything changes in the real list (a child is deleted, etc.) then the
list you are holding will suddenly have window references to garbage
SortChildren method is now supported, but currently only for the
default sort order.
+Added typemaps for wxSize, wxPoint, wxRealPoint, and wxRect that allow
+either the actual objects or Python sequence values to be used. For
+example, the following are equivallent:
+
+ win = wxWindow(parent, size = wxSize(100, 100))
+ win = wxWindow(parent, size = (100, 100))
+
+Super-charged the wxHtml module. You can now create your own tag
+handlers and also have access to the parser and cell classes. There
+is a tag handler in the library at wxPython.lib.wxpTag that
+understands the WXP tag and is able to place wxPython windows on HTML
+pages. See the demo for an example.
+
+A bunch of the methods of wxMenuBar were previously ifdef'd out for
+wxGTK. Added them back in since the methods exist now.
+
+Wrapped the wxHtmlHelpController and related classes.
+
+Wrapped the C++ versions of wxSizer and firends. The Python-only
+versions are still in the library, but depreciated. (You will get a
+warning message if you try to use them, but the warning can be
+disabled.) The usage of the C++ versions is slightly different, and
+the functionality of wxBorderSizer is now part of wxBoxSizer. I have
+added a few methods to wxSizer to try and make the transition as
+smooth as possible, I combined all Add methods into a single method
+that handles all cases, added an AddMany method, etc. One step I did
+not take was to make the default value of flag in the Add method be
+wxGROW. This would have made it more backward compatible, but less
+portable to and from wxWin C++ code. Please see the docs and demo for
+further details.
+
+Added wxPyEvent and wxPyCommandEvent classes, derived from wxEvent and
+wxCommandEvent. Each of them has SetPyData and GetPyData methods that
+accept or return a single Python object. You can use these classes
+directly or derive from them to create your own types of event objects
+that can pass through the wxWindows event system without loosing their
+Python parts (as long as they are stored with SetPyData.) Stay tuned
+for more info and examples in future releases.
+
+Added wxPython.lib.grids as an example of how to derive a new sizer
+from the C++ sizers. In this module you will find wxGridSizer and
+wxFlexGridSizer. wxGridSizer arrainges its items in a grid in which
+all the widths and heights are the same. wxFlexgridSizer allows
+different widths and heights, and you can also specify rows and/or
+columns that are growable. See the demo for a couple examples for how
+to use them.
+
+Added the wxValidator class, and created a class named wxPyValidator
+that should be used for the base class of any Python validators. See
+the demo for an example. Please not that you MUST implement a Clone
+method in your validator classes because of the way some things work
+in the underlying C++ library. I did not add wxTextValidator because
+of some issues of how it transfers data to and from a wxString, which
+in wxPython is automatically translated to and from Python strings, so
+there would never be a concrete wxString that would hang around long
+enough for the validator to do its job. On the other hand, it should
+be real easy to duplicate the functionality of wxTextValidator in a
+pure Python class derived from wxPyValidator.
+
+I've finally added a feature that has been on my list for close to two
+years! Ever wondered what that zero is for when you create your app
+object? Well now you can leave it out or explicitly set it to a true
+value. This value now controls what is to be done with sys.stdout and
+sys.stderr. A false value leaves them alone, and a true value sets
+them to an instance of wxPyOnDemandOutputWindow. (On windows the
+default is true, on other platforms the default is false.) This class
+creates a frame containing a wxTextCtrl as soon as anything is written
+to sys.stdout or sys.stderr. If you close the window it will come
+back again the next time something is written. (You can call
+app.RestoreStdio to turn this off.) If you would rather that the stdio be
+redirected to a file, you can provide a second parameter to your app
+object's constructor that is a filename. If you want to use your own
+class instead of wxPyOnDemandOutputWindow you can either implement
+RedirectStdio() in you app class or change the value of
+wxApp.outputWindowClass like this:
+
+ class MyApp(wxApp):
+ outputWindowClass = MyClass
+
+ def OnInit(self):
+ frame = MyFrame()
+ self.SetTopWindow(frame)
+ return true
+
+Please see the implementation of wxPyOnDemandOutputWindow and wxApp in
+wx.py for more details. A few words of caution: if you are running
+your app in a debugger, changing sys.stdout and sys.stderr is likely
+to really screw things up.
parameters with defaults to a method just to specify a
non-default value on the end. You can now do this instead:
- win = wxWindow(parent, -1, style = mystyle)
+ win = wxWindow(parent, -1, style = mystyle)
2. There is now an an equivalence between Python's None and C++'s
NULL. This means that any methods that might return NULL will
text = '''
<html>
<body bgcolor="#AC76DE">
-<center><table bgcolor="#458154" width="100%%" cellspacing="0" cellpadding="0" border="1">
+<center><table bgcolor="#458154" width="100%%" cellspacing="0"
+cellpadding="0" border="1">
<tr>
<td align="center"><h1>wxPython %s</h1></td>
</tr>
demo item so you can learn how to use the classes yourself.</p>
<p><b>wxPython</b> is brought to you by <b>Robin Dunn</b> and<br>
-<b>Total Control Software</b>, Copyright (c) 1998-1999.</p>
+<b>Total Control Software</b>, Copyright (c) 1997-1999.</p>
-<p><font size="-1">Please see <i>license.txt</i> for licensing information.</font></p>
+<p>
+<font size="-1">Please see <i>license.txt</i> for licensing information.</font>
+</p>
<p><wxp class="wxButton">
<param name="label" value="Okay">
</html>
'''
def __init__(self, parent):
- wxDialog.__init__(self, parent, -1, 'About wxPython')
- self.html = wxHtmlWindow(self, -1, wxPoint(5,5), wxSize(400, 350))
+ wxDialog.__init__(self, parent, -1, 'About the wxPython demo',
+ size=wxSize(420, 380))
+ self.html = wxHtmlWindow(self, -1)
self.html.SetPage(self.text % wx.__version__)
- self.Fit()
+ self.SetAutoLayout(true)
+ lc = wxLayoutConstraints()
+ lc.top.SameAs(self, wxTop, 5)
+ lc.left.SameAs(self, wxLeft, 5)
+ lc.bottom.SameAs(self, wxBottom, 5)
+ lc.right.SameAs(self, wxRight, 5)
+ self.html.SetConstraints(lc)
+ self.Layout()
+ self.CentreOnParent(wxBOTH)
#---------------------------------------------------------------------------
+
+
+
+
+
+
'wxTreeCtrl', 'wxSpinButton', 'wxStaticText', 'wxStaticBitmap',
'wxRadioBox', 'wxSlider']),
- ('Window Layout', ['wxLayoutConstraints', 'Sizers']),
+ ('Window Layout', ['wxLayoutConstraints', 'Sizers', 'OldSizers']),
- ('Miscellaneous', ['wxTimer', 'wxGLCanvas', 'DialogUnits', 'wxImage',
- 'PrintFramework', 'wxOGL']),
+ ('Miscellaneous', ['wxTimer', 'wxValidator', 'wxGLCanvas', 'DialogUnits',
+ 'wxImage', 'PrintFramework', 'wxOGL']),
- ('wxPython Library', ['Sizers', 'Layoutf', 'wxScrolledMessageDialog',
+ ('wxPython Library', ['OldSizers', 'Layoutf', 'wxScrolledMessageDialog',
'wxMultipleChoiceDialog', 'wxPlotCanvas']),
('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
class wxPythonDemo(wxFrame):
def __init__(self, parent, id, title):
- wxFrame.__init__(self, parent, -1, title,
- wxDefaultPosition, wxSize(700, 550))
+ wxFrame.__init__(self, parent, -1, title, size = (725, 550))
+
if wxPlatform == '__WXMSW__':
self.icon = wxIcon('bitmaps/mondrian.ico', wxBITMAP_TYPE_ICO)
self.SetIcon(self.icon)
# Make a File menu
self.mainmenu = wxMenuBar()
menu = wxMenu()
- mID = wxNewId()
- menu.Append(mID, 'E&xit', 'Get the heck outta here!')
- EVT_MENU(self, mID, self.OnFileExit)
+ exitID = wxNewId()
+ menu.Append(exitID, 'E&xit\tCtrl-X', 'Get the heck outta here!')
+ EVT_MENU(self, exitID, self.OnFileExit)
self.mainmenu.Append(menu, '&File')
# Make a Demo menu
# Make a Help menu
- mID = wxNewId()
+ helpID = wxNewId()
menu = wxMenu()
- menu.Append(mID, '&About', 'wxPython RULES!!!')
- EVT_MENU(self, mID, self.OnHelpAbout)
+ menu.Append(helpID, '&About\tCtrl-H', 'wxPython RULES!!!')
+ EVT_MENU(self, helpID, self.OnHelpAbout)
self.mainmenu.Append(menu, '&Help')
self.SetMenuBar(self.mainmenu)
+ # set the menu accellerator table...
+ aTable = wxAcceleratorTable([(wxACCEL_CTRL, ord('X'), exitID),
+ (wxACCEL_CTRL, ord('H'), helpID)])
+ self.SetAcceleratorTable(aTable)
+
# Create a TreeCtrl
tID = wxNewId()
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)
+ ###EVT_TREE_SEL_CHANGING (self.tree, tID, self.OnSelChanging)
# Create a Notebook
self.nb = wxNotebook(splitter2, -1)
def OnSelChanged(self, event):
if self.dying:
return
+ ###print 'OnSelChanged entry'
if self.nb.GetPageCount() == 3:
if self.nb.GetSelection() == 2:
self.txt.Clear()
self.window = None
+ ###print 'OnSelChanged exit: ', itemText
+
+ ###def OnSelChanging(self, event):
+ ### print 'OnSelChanging'
+
#---------------------------------------------
# Get the Demo files
#---------------------------------------------
def OnDemoMenu(self, event):
- print event.GetId(), self.mainmenu.GetLabel(event.GetId())
try:
selectedDemo = self.treeMap[self.mainmenu.GetLabel(event.GetId())]
except:
selectedDemo = None
if selectedDemo:
+ ###print "---- start ----"
self.tree.SelectItem(selectedDemo)
self.tree.EnsureVisible(selectedDemo)
-
+ ###print "---- end ----"
#---------------------------------------------------------------------------
--- /dev/null
+#----------------------------------------------------------------------
+# sizer test code
+#----------------------------------------------------------------------
+
+from wxPython.wx import *
+from wxPython.lib.sizers import *
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox1(win):
+ box = wxBoxSizer(wxHORIZONTAL)
+ box.Add(wxButton(win, 1010, "one"), 0)
+ box.Add(wxButton(win, 1010, "two"), 0)
+ box.Add(wxButton(win, 1010, "three"), 0)
+ box.Add(wxButton(win, 1010, "four"), 0)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox2(win):
+ box = wxBoxSizer(wxVERTICAL)
+ box.Add(wxButton(win, 1010, "one"), 0)
+ box.Add(wxButton(win, 1010, "two"), 0)
+ box.Add(wxButton(win, 1010, "three"), 0)
+ box.Add(wxButton(win, 1010, "four"), 0)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox3(win):
+ box = wxBoxSizer(wxHORIZONTAL)
+ box.Add(wxButton(win, 1010, "one"), 0)
+ box.Add(wxButton(win, 1010, "two"), 0)
+ box.Add(wxButton(win, 1010, "three"), 0)
+ box.Add(wxButton(win, 1010, "four"), 0)
+ box.Add(wxButton(win, 1010, "five"), 1)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox4(win):
+ box = wxBoxSizer(wxHORIZONTAL)
+ box.Add(wxButton(win, 1010, "one"), 0)
+ box.Add(wxButton(win, 1010, "two"), 0)
+ box.Add(wxButton(win, 1010, "three"), 1)
+ box.Add(wxButton(win, 1010, "four"), 1)
+ box.Add(wxButton(win, 1010, "five"), 1)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox5(win):
+ box = wxBoxSizer(wxHORIZONTAL)
+ box.Add(wxButton(win, 1010, "one"), 0)
+ box.Add(wxButton(win, 1010, "two"), 0)
+ box.Add(wxButton(win, 1010, "three"), 3)
+ box.Add(wxButton(win, 1010, "four"), 1)
+ box.Add(wxButton(win, 1010, "five"), 1)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox6(win):
+ box = wxBoxSizer(wxHORIZONTAL, wxSize(250, 50))
+ box.Add(wxButton(win, 1010, "10"), 10)
+ box.Add(wxButton(win, 1010, "20"), 20)
+ box.Add(wxButton(win, 1010, "30"), 30)
+ box.Add(wxButton(win, 1010, "15"), 15)
+ box.Add(wxButton(win, 1010, "5"), 5)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder1(win):
+ bdr = wxBorderSizer(wxALL)
+ btn = wxButton(win, 1010, "border")
+ btn.SetSize(wxSize(80, 80))
+ bdr.Add(btn, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder2(win):
+ bdr = wxBorderSizer(wxEAST | wxWEST)
+ btn = wxButton(win, 1010, "border")
+ btn.SetSize(wxSize(80, 80))
+ bdr.Add(btn, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder3(win):
+ bdr = wxBorderSizer(wxNORTH | wxWEST)
+ btn = wxButton(win, 1010, "border")
+ btn.SetSize(wxSize(80, 80))
+ bdr.Add(btn, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
+def makeBoxInBox(win):
+ box = wxBoxSizer(wxVERTICAL)
+
+ box.Add(wxButton(win, 1010, "one"))
+
+ box2 = wxBoxSizer(wxHORIZONTAL)
+ box2.AddMany([ wxButton(win, 1010, "two"),
+ wxButton(win, 1010, "three"),
+ wxButton(win, 1010, "four"),
+ wxButton(win, 1010, "five"),
+ ])
+
+ box3 = wxBoxSizer(wxVERTICAL)
+ box3.AddMany([ (wxButton(win, 1010, "six"), 0),
+ (wxButton(win, 1010, "seven"), 2),
+ (wxButton(win, 1010, "eight"), 1),
+ (wxButton(win, 1010, "nine"), 1),
+ ])
+
+ box2.Add(box3, 1)
+ box.Add(box2, 1)
+
+ box.Add(wxButton(win, 1010, "ten"))
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeBoxInBorder(win):
+ bdr = wxBorderSizer(wxALL)
+ box = makeSimpleBox3(win)
+ bdr.Add(box, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+
+def makeBorderInBox(win):
+ insideBox = wxBoxSizer(wxHORIZONTAL)
+
+ box2 = wxBoxSizer(wxHORIZONTAL)
+ box2.AddMany([ wxButton(win, 1010, "one"),
+ wxButton(win, 1010, "two"),
+ wxButton(win, 1010, "three"),
+ wxButton(win, 1010, "four"),
+ wxButton(win, 1010, "five"),
+ ])
+
+ insideBox.Add(box2, 0)
+
+ bdr = wxBorderSizer(wxALL)
+ bdr.Add(wxButton(win, 1010, "border"), 20)
+ insideBox.Add(bdr, 1)
+
+ box3 = wxBoxSizer(wxVERTICAL)
+ box3.AddMany([ (wxButton(win, 1010, "six"), 0),
+ (wxButton(win, 1010, "seven"), 2),
+ (wxButton(win, 1010, "eight"), 1),
+ (wxButton(win, 1010, "nine"), 1),
+ ])
+ insideBox.Add(box3, 1)
+
+ outsideBox = wxBoxSizer(wxVERTICAL)
+ outsideBox.Add(wxButton(win, 1010, "top"))
+ outsideBox.Add(insideBox, 1)
+ outsideBox.Add(wxButton(win, 1010, "bottom"))
+
+ return outsideBox
+
+
+#----------------------------------------------------------------------
+
+theTests = [
+ ("Simple horizontal boxes", makeSimpleBox1,
+ "This is a HORIZONTAL box sizer with four non-stretchable buttons held "
+ "within it. Notice that the buttons are added and aligned in the horizontal "
+ "dimension. Also notice that they are fixed size in the horizontal dimension, "
+ "but will stretch vertically."
+ ),
+
+ ("Simple vertical boxes", makeSimpleBox2,
+ "Exactly the same as the previous sample but using a VERTICAL box sizer "
+ "instead of a HORIZONTAL one."
+ ),
+
+ ("Add a stretchable", makeSimpleBox3,
+ "We've added one more button with the strechable flag turned on. Notice "
+ "how it grows to fill the extra space in the otherwise fixed dimension."
+ ),
+
+ ("More than one stretchable", makeSimpleBox4,
+ "Here there are several items that are stretchable, they all divide up the "
+ "extra space evenly."
+ ),
+
+ ("Weighting factor", makeSimpleBox5,
+ "This one shows more than one strechable, but one of them has a weighting "
+ "factor so it gets more of the free space."
+ ),
+
+# ("Percent Sizer", makeSimpleBox6,
+# "You can use the wxBoxSizer like a Percent Sizer. Just make sure that all "
+# "the weighting factors add up to 100!"
+# ),
+
+ ("", None, ""),
+
+ ("Simple border sizer", makeSimpleBorder1,
+ "The wxBorderSizer leaves empty space around its contents. This one "
+ "gives a border all the way around."
+ ),
+
+ ("East and West border", makeSimpleBorder2,
+ "You can pick and choose which sides have borders."
+ ),
+
+ ("North and West border", makeSimpleBorder3,
+ "You can pick and choose which sides have borders."
+ ),
+
+ ("", None, ""),
+
+ ("Boxes inside of boxes", makeBoxInBox,
+ "This one shows nesting of boxes within boxes within boxes, using both "
+ "orientations. Notice also that button seven has a greater weighting "
+ "factor than its siblings."
+ ),
+
+ ("Boxes inside a Border", makeBoxInBorder,
+ "Sizers of different types can be nested withing each other as well. "
+ "Here is a box sizer with several buttons embedded within a border sizer."
+ ),
+
+ ("Border in a Box", makeBorderInBox,
+ "Another nesting example. This one has Boxes and a Border inside another Box."
+ ),
+
+ ]
+#----------------------------------------------------------------------
+
+class TestFrame(wxFrame):
+ def __init__(self, parent, title, sizerFunc):
+ wxFrame.__init__(self, parent, -1, title)
+ EVT_BUTTON(self, 1010, self.OnButton)
+
+ self.sizer = sizerFunc(self)
+ self.CreateStatusBar()
+ self.SetStatusText("Resize this frame to see how the sizers respond...")
+ self.sizer.FitWindow(self)
+
+
+ def OnSize(self, event):
+ size = self.GetClientSize()
+ self.sizer.Layout(size)
+
+ def OnCloseWindow(self, event):
+ self.MakeModal(false)
+ self.Destroy()
+
+ def OnButton(self, event):
+ self.Close(true)
+
+#----------------------------------------------------------------------
+
+
+
+class TestSelectionPanel(wxPanel):
+ def __init__(self, parent, frame):
+ wxPanel.__init__(self, parent, -1)
+ self.frame = frame
+
+ self.list = wxListBox(self, 401,
+ wxDLG_PNT(self, 10, 10), wxDLG_SZE(self, 100, 60),
+ [])
+ EVT_LISTBOX(self, 401, self.OnSelect)
+ EVT_LISTBOX_DCLICK(self, 401, self.OnDClick)
+
+ wxButton(self, 402, "Try it!", wxDLG_PNT(self, 120, 10)).SetDefault()
+ EVT_BUTTON(self, 402, self.OnDClick)
+
+ self.text = wxTextCtrl(self, -1, "",
+ wxDLG_PNT(self, 10, 80),
+ wxDLG_SZE(self, 200, 60),
+ wxTE_MULTILINE | wxTE_READONLY)
+
+ for item in theTests:
+ self.list.Append(item[0])
+
+
+
+ def OnSelect(self, event):
+ pos = self.list.GetSelection()
+ self.text.SetValue(theTests[pos][2])
+
+
+ def OnDClick(self, event):
+ pos = self.list.GetSelection()
+ title = theTests[pos][0]
+ func = theTests[pos][1]
+
+ if func:
+ win = TestFrame(self, title, func)
+ win.CentreOnParent(wxBOTH)
+ win.Show(true)
+ win.MakeModal(true)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestSelectionPanel(nb, frame)
+ return win
+
+overview = wxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
+ wxBoxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
+ wxBorderSizer.__doc__
+
+#----------------------------------------------------------------------
+
+
+
+if __name__ == '__main__':
+
+ class MainFrame(wxFrame):
+ def __init__(self):
+ wxFrame.__init__(self, NULL, -1, "Testing...")
+
+ self.CreateStatusBar()
+ mainmenu = wxMenuBar()
+ menu = wxMenu()
+ menu.Append(200, 'E&xit', 'Get the heck outta here!')
+ mainmenu.Append(menu, "&File")
+ self.SetMenuBar(mainmenu)
+ EVT_MENU(self, 200, self.OnExit)
+ self.panel = TestSelectionPanel(self, self)
+ self.SetSize(wxSize(400, 380))
+
+ def OnCloseWindow(self, event):
+ self.Destroy()
+
+ def OnExit(self, event):
+ self.Close(true)
+
+
+ class TestApp(wxApp):
+ def OnInit(self):
+ frame = MainFrame()
+ frame.Show(true)
+ self.SetTopWindow(frame)
+ return true
+
+ app = TestApp(0)
+ app.MainLoop()
+
+
+#----------------------------------------------------------------------
from wxPython.wx import *
-from wxPython.lib.sizers import *
from wxScrolledWindow import MyCanvas
#----------------------------------------------------------------------
self.printData = wxPrintData()
self.printData.SetPaperId(wxPAPER_LETTER)
- self.box = box.wxBoxSizer(wxVERTICAL)
+ self.box = wxBoxSizer(wxVERTICAL)
self.canvas = MyCanvas(self)
- self.box.Add(self.canvas, 1)
+ self.box.Add(self.canvas, 1, wxGROW)
subbox = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(self, 1201, "Print Setup")
EVT_BUTTON(self, 1201, self.OnPrintSetup)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1202, "Print Preview")
EVT_BUTTON(self, 1202, self.OnPrintPreview)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1203, "Print")
EVT_BUTTON(self, 1203, self.OnDoPrint)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
- self.box.Add(subbox)
+ self.box.Add(subbox, 0, wxGROW)
+ self.SetAutoLayout(true)
+ self.SetSizer(self.box)
- def OnSize(self, event):
- size = self.GetClientSize()
- self.box.Layout(size)
-
def OnPrintSetup(self, event):
printerDialog = wxPrintDialog(self)
printerDialog.GetPrintDialogData().SetPrintData(self.printData)
# sizer test code
#----------------------------------------------------------------------
-from wxPython.wx import *
-from wxPython.lib.sizers import *
+from wxPython.wx import *
+from wxPython.lib.grids import wxGridSizer, wxFlexGridSizer
#----------------------------------------------------------------------
def makeSimpleBox1(win):
box = wxBoxSizer(wxHORIZONTAL)
- box.Add(wxButton(win, 1010, "one"), 0)
- box.Add(wxButton(win, 1010, "two"), 0)
- box.Add(wxButton(win, 1010, "three"), 0)
- box.Add(wxButton(win, 1010, "four"), 0)
+ box.Add(wxButton(win, 1010, "one"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "two"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "three"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "four"), 0, wxGROW)
return box
def makeSimpleBox2(win):
box = wxBoxSizer(wxVERTICAL)
- box.Add(wxButton(win, 1010, "one"), 0)
- box.Add(wxButton(win, 1010, "two"), 0)
- box.Add(wxButton(win, 1010, "three"), 0)
- box.Add(wxButton(win, 1010, "four"), 0)
+ box.Add(wxButton(win, 1010, "one"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "two"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "three"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "four"), 0, wxGROW)
return box
def makeSimpleBox3(win):
box = wxBoxSizer(wxHORIZONTAL)
- box.Add(wxButton(win, 1010, "one"), 0)
- box.Add(wxButton(win, 1010, "two"), 0)
- box.Add(wxButton(win, 1010, "three"), 0)
- box.Add(wxButton(win, 1010, "four"), 0)
- box.Add(wxButton(win, 1010, "five"), 1)
+ box.Add(wxButton(win, 1010, "one"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "two"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "three"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "four"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "five"), 1, wxGROW)
return box
def makeSimpleBox4(win):
box = wxBoxSizer(wxHORIZONTAL)
- box.Add(wxButton(win, 1010, "one"), 0)
- box.Add(wxButton(win, 1010, "two"), 0)
- box.Add(wxButton(win, 1010, "three"), 1)
- box.Add(wxButton(win, 1010, "four"), 1)
- box.Add(wxButton(win, 1010, "five"), 1)
+ box.Add(wxButton(win, 1010, "one"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "two"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "three"), 1, wxGROW)
+ box.Add(wxButton(win, 1010, "four"), 1, wxGROW)
+ box.Add(wxButton(win, 1010, "five"), 1, wxGROW)
return box
def makeSimpleBox5(win):
box = wxBoxSizer(wxHORIZONTAL)
- box.Add(wxButton(win, 1010, "one"), 0)
- box.Add(wxButton(win, 1010, "two"), 0)
- box.Add(wxButton(win, 1010, "three"), 3)
- box.Add(wxButton(win, 1010, "four"), 1)
- box.Add(wxButton(win, 1010, "five"), 1)
+ box.Add(wxButton(win, 1010, "one"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "two"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "three"), 3, wxGROW)
+ box.Add(wxButton(win, 1010, "four"), 1, wxGROW)
+ box.Add(wxButton(win, 1010, "five"), 1, wxGROW)
return box
#----------------------------------------------------------------------
def makeSimpleBox6(win):
- box = wxBoxSizer(wxHORIZONTAL, wxSize(250, 50))
- box.Add(wxButton(win, 1010, "10"), 10)
- box.Add(wxButton(win, 1010, "20"), 20)
- box.Add(wxButton(win, 1010, "30"), 30)
- box.Add(wxButton(win, 1010, "15"), 15)
- box.Add(wxButton(win, 1010, "5"), 5)
+ box = wxBoxSizer(wxHORIZONTAL)
+ box.Add(wxButton(win, 1010, "one"), 1, wxALIGN_TOP)
+ box.Add(wxButton(win, 1010, "two"), 1, wxGROW)
+ box.Add(wxButton(win, 1010, "three"), 1, wxCENTER)
+ box.Add(wxButton(win, 1010, "four"), 1, wxGROW)
+ box.Add(wxButton(win, 1010, "five"), 1, wxALIGN_BOTTOM)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox7(win):
+ box = wxBoxSizer(wxHORIZONTAL)
+ box.Add(wxButton(win, 1010, "one"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "two"), 0, wxGROW)
+ box.Add(wxButton(win, 1010, "three"), 0, wxGROW)
+ box.Add(60, 20, 0, wxGROW)
+ box.Add(wxButton(win, 1010, "five"), 1, wxGROW)
return box
#----------------------------------------------------------------------
+#----------------------------------------------------------------------
def makeSimpleBorder1(win):
- bdr = wxBorderSizer(wxALL)
+ bdr = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
- bdr.Add(btn, 15)
+ bdr.Add(btn, 1, wxGROW|wxALL, 15)
return bdr
#----------------------------------------------------------------------
def makeSimpleBorder2(win):
- bdr = wxBorderSizer(wxEAST | wxWEST)
+ bdr = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
- bdr.Add(btn, 15)
+ bdr.Add(btn, 1, wxGROW | wxEAST | wxWEST, 15)
return bdr
#----------------------------------------------------------------------
def makeSimpleBorder3(win):
- bdr = wxBorderSizer(wxNORTH | wxWEST)
+ bdr = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
- bdr.Add(btn, 15)
+ bdr.Add(btn, 1, wxGROW | wxNORTH | wxWEST, 15)
return bdr
def makeBoxInBox(win):
box = wxBoxSizer(wxVERTICAL)
- box.Add(wxButton(win, 1010, "one"))
+ box.Add(wxButton(win, 1010, "one"), 0, wxGROW)
box2 = wxBoxSizer(wxHORIZONTAL)
- box2.AddMany([ wxButton(win, 1010, "two"),
- wxButton(win, 1010, "three"),
- wxButton(win, 1010, "four"),
- wxButton(win, 1010, "five"),
+ box2.AddMany([ (wxButton(win, 1010, "two"), 0, wxGROW),
+ (wxButton(win, 1010, "three"), 0, wxGROW),
+ (wxButton(win, 1010, "four"), 0, wxGROW),
+ (wxButton(win, 1010, "five"), 0, wxGROW),
])
box3 = wxBoxSizer(wxVERTICAL)
- box3.AddMany([ (wxButton(win, 1010, "six"), 0),
- (wxButton(win, 1010, "seven"), 2),
- (wxButton(win, 1010, "eight"), 1),
- (wxButton(win, 1010, "nine"), 1),
+ box3.AddMany([ (wxButton(win, 1010, "six"), 0, wxGROW),
+ (wxButton(win, 1010, "seven"), 2, wxGROW),
+ (wxButton(win, 1010, "eight"), 1, wxGROW),
+ (wxButton(win, 1010, "nine"), 1, wxGROW),
])
- box2.Add(box3, 1)
- box.Add(box2, 1)
+ box2.Add(box3, 1, wxGROW)
+ box.Add(box2, 1, wxGROW)
- box.Add(wxButton(win, 1010, "ten"))
+ box.Add(wxButton(win, 1010, "ten"), 0, wxGROW)
return box
#----------------------------------------------------------------------
def makeBoxInBorder(win):
- bdr = wxBorderSizer(wxALL)
+ bdr = wxBoxSizer(wxHORIZONTAL)
box = makeSimpleBox3(win)
- bdr.Add(box, 15)
+ bdr.Add(box, 1, wxGROW | wxALL, 15)
return bdr
insideBox = wxBoxSizer(wxHORIZONTAL)
box2 = wxBoxSizer(wxHORIZONTAL)
- box2.AddMany([ wxButton(win, 1010, "one"),
- wxButton(win, 1010, "two"),
- wxButton(win, 1010, "three"),
- wxButton(win, 1010, "four"),
- wxButton(win, 1010, "five"),
+ box2.AddMany([ (wxButton(win, 1010, "one"), 0, wxGROW),
+ (wxButton(win, 1010, "two"), 0, wxGROW),
+ (wxButton(win, 1010, "three"), 0, wxGROW),
+ (wxButton(win, 1010, "four"), 0, wxGROW),
+ (wxButton(win, 1010, "five"), 0, wxGROW),
])
- insideBox.Add(box2, 0)
+ insideBox.Add(box2, 0, wxGROW)
- bdr = wxBorderSizer(wxALL)
- bdr.Add(wxButton(win, 1010, "border"), 20)
- insideBox.Add(bdr, 1)
+ bdr = wxBoxSizer(wxHORIZONTAL)
+ bdr.Add(wxButton(win, 1010, "border"), 1, wxGROW | wxALL)
+ insideBox.Add(bdr, 1, wxGROW | wxALL, 20)
box3 = wxBoxSizer(wxVERTICAL)
- box3.AddMany([ (wxButton(win, 1010, "six"), 0),
- (wxButton(win, 1010, "seven"), 2),
- (wxButton(win, 1010, "eight"), 1),
- (wxButton(win, 1010, "nine"), 1),
+ box3.AddMany([ (wxButton(win, 1010, "six"), 0, wxGROW),
+ (wxButton(win, 1010, "seven"), 2, wxGROW),
+ (wxButton(win, 1010, "eight"), 1, wxGROW),
+ (wxButton(win, 1010, "nine"), 1, wxGROW),
])
- insideBox.Add(box3, 1)
+ insideBox.Add(box3, 1, wxGROW)
outsideBox = wxBoxSizer(wxVERTICAL)
- outsideBox.Add(wxButton(win, 1010, "top"))
- outsideBox.Add(insideBox, 1)
- outsideBox.Add(wxButton(win, 1010, "bottom"))
+ outsideBox.Add(wxButton(win, 1010, "top"), 0, wxGROW)
+ outsideBox.Add(insideBox, 1, wxGROW)
+ outsideBox.Add(wxButton(win, 1010, "bottom"), 0, wxGROW)
return outsideBox
#----------------------------------------------------------------------
+def makeGrid1(win):
+ gs = wxGridSizer(3, 3, 2, 2) # rows, cols, hgap, vgap
+
+ gs.AddMany([ (wxButton(win, 1010, 'one'), 0, wxGROW),
+ (wxButton(win, 1010, 'two'), 0, wxGROW),
+ (wxButton(win, 1010, 'three'), 0, wxGROW),
+ (wxButton(win, 1010, 'four'), 0, wxGROW),
+ (wxButton(win, 1010, 'five'), 0, wxGROW),
+ #(75, 50),
+ (wxButton(win, 1010, 'six'), 0, wxGROW),
+ (wxButton(win, 1010, 'seven'), 0, wxGROW),
+ (wxButton(win, 1010, 'eight'), 0, wxGROW),
+ (wxButton(win, 1010, 'nine'), 0, wxGROW),
+ ])
+
+ return gs
+
+#----------------------------------------------------------------------
+
+def makeGrid2(win):
+ gs = wxGridSizer(3, 3) # rows, cols, hgap, vgap
+
+ box = wxBoxSizer(wxVERTICAL)
+ box.Add(wxButton(win, 1010, 'A'), 0, wxGROW)
+ box.Add(wxButton(win, 1010, 'B'), 1, wxGROW)
+
+ gs2 = wxGridSizer(2,2, 4, 4)
+ gs2.AddMany([ (wxButton(win, 1010, 'C'), 0, wxGROW),
+ (wxButton(win, 1010, 'E'), 0, wxGROW),
+ (wxButton(win, 1010, 'F'), 0, wxGROW),
+ (wxButton(win, 1010, 'G'), 0, wxGROW)])
+
+ gs.AddMany([ (wxButton(win, 1010, 'one'), 0, wxALIGN_RIGHT | wxALIGN_BOTTOM),
+ (wxButton(win, 1010, 'two'), 0, wxGROW),
+ (wxButton(win, 1010, 'three'), 0, wxALIGN_LEFT | wxALIGN_BOTTOM),
+ (wxButton(win, 1010, 'four'), 0, wxGROW),
+ (wxButton(win, 1010, 'five'), 0, wxCENTER),
+ (wxButton(win, 1010, 'six'), 0, wxGROW),
+ (box, 0, wxGROW | wxALL, 10),
+ (wxButton(win, 1010, 'eight'), 0, wxGROW),
+ (gs2, 0, wxGROW | wxALL, 4),
+ ])
+
+ return gs
+
+#----------------------------------------------------------------------
+
+def makeGrid3(win):
+ gs = wxFlexGridSizer(3, 3, 2, 2) # rows, cols, hgap, vgap
+
+ gs.AddMany([ (wxButton(win, 1010, 'one'), 0, wxGROW),
+ (wxButton(win, 1010, 'two'), 0, wxGROW),
+ (wxButton(win, 1010, 'three'), 0, wxGROW),
+ (wxButton(win, 1010, 'four'), 0, wxGROW),
+ #(wxButton(win, 1010, 'five'), 0, wxGROW),
+ (175, 50),
+ (wxButton(win, 1010, 'six'), 0, wxGROW),
+ (wxButton(win, 1010, 'seven'), 0, wxGROW),
+ (wxButton(win, 1010, 'eight'), 0, wxGROW),
+ (wxButton(win, 1010, 'nine'), 0, wxGROW),
+ ])
+
+ gs.AddGrowableRow(0)
+ gs.AddGrowableRow(2)
+ gs.AddGrowableCol(1)
+ return gs
+
+#----------------------------------------------------------------------
+
theTests = [
("Simple horizontal boxes", makeSimpleBox1,
"This is a HORIZONTAL box sizer with four non-stretchable buttons held "
"factor so it gets more of the free space."
),
+ ("Edge Affinity", makeSimpleBox6,
+ "For items that don't completly fill their allotted space, and don't "
+ "stretch, you can specify which side (or the center) they should stay "
+ "attached to."
+ ),
+
+ ("Spacer", makeSimpleBox7,
+ "You can add empty space to be managed by a Sizer just as if it were a "
+ "window or another Sizer."
+ ),
+
# ("Percent Sizer", makeSimpleBox6,
# "You can use the wxBoxSizer like a Percent Sizer. Just make sure that all "
# "the weighting factors add up to 100!"
"Another nesting example. This one has Boxes and a Border inside another Box."
),
+ ("", None, ""),
+
+ ("Simple Grid", makeGrid1,
+ "This is an example of the wxGridSizer. In this case all row heights "
+ "and column widths are kept the same as all the others and all items "
+ "fill their available space. The horzontal and vertical gaps are set to "
+ "2 pixels each."
+ ),
+
+ ("More Grid Features", makeGrid2,
+ "This is another example of the wxGridSizer. This one has no gaps in the grid, "
+ "but various cells are given different alignment options and some of them "
+ "hold nested sizers."
+ ),
+
+ ("Flexible Grid", makeGrid3,
+ "This grid allows the rows to have different heights and the columns to have "
+ "different widths. You can also specify rows and columns that are growable, "
+ "which we have done for the first and last row and the middle column for "
+ "this example.\n"
+ "\nThere is also a spacer in the middle cell instead of an actual window."
+ ),
+
]
#----------------------------------------------------------------------
self.sizer = sizerFunc(self)
self.CreateStatusBar()
self.SetStatusText("Resize this frame to see how the sizers respond...")
- self.sizer.FitWindow(self)
-
+ self.sizer.Fit(self)
- def OnSize(self, event):
- size = self.GetClientSize()
- self.sizer.Layout(size)
+ self.SetAutoLayout(true)
+ self.SetSizer(self.sizer)
def OnCloseWindow(self, event):
self.MakeModal(false)
self.frame = frame
self.list = wxListBox(self, 401,
- wxDLG_PNT(self, 10, 10), wxDLG_SZE(self, 100, 60),
+ wxDLG_PNT(self, 10, 10), wxDLG_SZE(self, 100, 100),
[])
EVT_LISTBOX(self, 401, self.OnSelect)
EVT_LISTBOX_DCLICK(self, 401, self.OnDClick)
- wxButton(self, 402, "Try it!", wxDLG_PNT(self, 120, 10)).SetDefault()
+ self.btn = wxButton(self, 402, "Try it!", wxDLG_PNT(self, 120, 10)).SetDefault()
EVT_BUTTON(self, 402, self.OnDClick)
self.text = wxTextCtrl(self, -1, "",
- wxDLG_PNT(self, 10, 80),
- wxDLG_SZE(self, 200, 60),
+ wxDLG_PNT(self, 10, 115),
+ wxDLG_SZE(self, 200, 50),
wxTE_MULTILINE | wxTE_READONLY)
for item in theTests:
win = TestSelectionPanel(nb, frame)
return win
-overview = wxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
- wxBoxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
- wxBorderSizer.__doc__
+overview = ""
+#wxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
+#wxBoxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
+#wxBorderSizer.__doc__
#----------------------------------------------------------------------
mainmenu.Append(menu, "&File")
self.SetMenuBar(mainmenu)
EVT_MENU(self, 200, self.OnExit)
- self.panel = TestSelectionPanel(self)
+ self.panel = TestSelectionPanel(self, self)
self.SetSize(wxSize(400, 380))
def OnCloseWindow(self, event):
from wxPython.wx import *
from wxPython.html import *
-from wxPython.lib.sizers import *
import wxPython.lib.wxpTag
#----------------------------------------------------------------------
self.html.SetRelatedFrame(frame, "wxPython: (A Demonstration) -- %s")
self.html.SetRelatedStatusBar(0)
- self.box = box.wxBoxSizer(wxVERTICAL)
- self.box.Add(self.html, 1)
+ self.box = wxBoxSizer(wxVERTICAL)
+ self.box.Add(self.html, 1, wxGROW)
subbox = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(self, 1201, "Show Default")
EVT_BUTTON(self, 1201, self.OnShowDefault)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1202, "Load File")
EVT_BUTTON(self, 1202, self.OnLoadFile)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1203, "With Widgets")
EVT_BUTTON(self, 1203, self.OnWithWidgets)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1204, "Back")
EVT_BUTTON(self, 1204, self.OnBack)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1205, "Forward")
EVT_BUTTON(self, 1205, self.OnForward)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1206, "View Source")
EVT_BUTTON(self, 1206, self.OnViewSource)
- subbox.Add(btn, 1)
+ subbox.Add(btn, 1, wxGROW | wxALL, 2)
- self.box.Add(subbox)
+ self.box.Add(subbox, 0, wxGROW)
+ self.SetSizer(self.box)
+ self.SetAutoLayout(true)
# A button with this ID is created on the widget test page.
EVT_BUTTON(self, wxID_OK, self.OnOk)
- def OnSize(self, event):
- size = self.GetClientSize()
- self.box.Layout(size)
-
def OnShowDefault(self, event):
name = os.path.join(os.path.split(sys.argv[0])[0], 'data/test.htm')
self.diagram.SetCanvas(self)
self.shapes = []
- self.MyAddShape(wxCircleShape(80), 100, 100, wxPen(wxBLUE, 3), wxGREEN_BRUSH)
- self.MyAddShape(wxRectangleShape(85, 50), 305, 60, wxBLACK_PEN, wxLIGHT_GREY_BRUSH)
- self.MyAddShape(DiamondShape(90, 90), 345, 235, wxPen(wxBLUE, 3, wxDOT), wxRED_BRUSH)
- self.MyAddShape(RoundedRectangleShape(95,70), 140, 255, wxPen(wxRED, 1), wxBLUE_BRUSH)
+ rRectBrush = wxBrush(wxNamedColour("MEDIUM TURQUOISE"), wxSOLID)
+
+ self.MyAddShape(wxCircleShape(80), 100, 100, wxPen(wxBLUE, 3), wxGREEN_BRUSH, "Circle")
+ self.MyAddShape(wxRectangleShape(85, 50), 305, 60, wxBLACK_PEN, wxLIGHT_GREY_BRUSH, "Rectangle")
+ self.MyAddShape(DiamondShape(90, 90), 345, 235, wxPen(wxBLUE, 3, wxDOT), wxRED_BRUSH, "Polygon")
+ self.MyAddShape(RoundedRectangleShape(95,70), 140, 255, wxPen(wxRED, 1), rRectBrush, "Rounded Rect")
dc = wxClientDC(self)
self.PrepareDC(dc)
- def MyAddShape(self, shape, x, y, pen, brush):
+ def MyAddShape(self, shape, x, y, pen, brush, text):
shape.SetDraggable(true)
shape.SetCanvas(self)
shape.SetX(x)
shape.SetY(y)
shape.SetPen(pen)
shape.SetBrush(brush)
+ shape.AddText(text)
#shape.SetShadowMode(SHADOW_RIGHT)
self.diagram.AddShape(shape)
shape.Show(true)
p2.SetBackgroundColour(wxBLUE)
wxStaticText(p2, -1, "Panel Two", wxPoint(5,5)).SetBackgroundColour(wxBLUE)
+ splitter.SetMinimumPaneSize(20)
splitter.SplitVertically(p1, p2)
splitter.SetSashPosition(100)
- splitter.SetMinimumPaneSize(20)
return splitter
self.CreateStatusBar()
- tb.AddTool(10, wxNoRefBitmap('bitmaps/new.bmp', wxBITMAP_TYPE_BMP),
- wxNullBitmap, false, -1, -1, "New", "Long help for 'New'")
+ tb.AddTool(10, wxBitmap('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")
+ tb.AddTool(20, wxBitmap('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")
+ tb.AddTool(30, wxBitmap('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")
+ tb.AddTool(40, wxBitmap('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")
+ tb.AddTool(50, wxBitmap('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")
+ tb.AddTool(60, wxBitmap('bitmaps/tog1.bmp', wxBITMAP_TYPE_BMP),
+ wxBitmap('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)
tID = NewId()
self.tree = wxTreeCtrl(self, tID, wxDefaultPosition, wxDefaultSize,
- wxTR_HAS_BUTTONS | wxTR_EDIT_LABELS)
+ wxTR_HAS_BUTTONS | wxTR_EDIT_LABELS) #| wxTR_MULTIPLE)
self.root = self.tree.AddRoot("The Root Item")
for x in range(15):
--- /dev/null
+
+from wxPython.wx import *
+from wxPython.lib.grids import wxFlexGridSizer
+
+import string
+
+#----------------------------------------------------------------------
+
+ALPHA_ONLY = 1
+DIGIT_ONLY = 2
+
+class MyValidator(wxPyValidator):
+ def __init__(self, flag=None, pyVar=None):
+ wxPyValidator.__init__(self)
+ self.flag = flag
+ EVT_CHAR(self, self.OnChar)
+
+ def Clone(self):
+ return MyValidator(self.flag)
+
+ def Validate(self, win):
+ print 'validate'
+ tc = wxPyTypeCast(win, "wxTextCtrl")
+ val = tc.GetValue()
+ if self.flag == ALPHA_ONLY:
+ for x in val:
+ if x not in string.letters:
+ return false
+
+ elif self.flag == DIGIT_ONLY:
+ for x in val:
+ if x not in string.digits:
+ return false
+
+ return true
+
+
+ def OnChar(self, event):
+ key = event.KeyCode()
+ if key < WXK_SPACE or key == WXK_DELETE or key > 255:
+ event.Skip()
+ return
+ if self.flag == ALPHA_ONLY and chr(key) in string.letters:
+ event.Skip()
+ return
+ if self.flag == DIGIT_ONLY and chr(key) in string.digits:
+ event.Skip()
+ return
+
+ if not wxValidator_IsSilent():
+ wxBell()
+
+ # Returning without calling even.Skip eats the event before it
+ # gets to the text control
+ return
+
+#----------------------------------------------------------------------
+
+class TestValidatorPanel(wxPanel):
+ def __init__(self, parent):
+ wxPanel.__init__(self, parent, -1)
+ self.SetAutoLayout(true)
+ VSPACE = 10
+
+ fgs = wxFlexGridSizer(0, 2)
+
+ fgs.Add(1,1);
+ fgs.Add(wxStaticText(self, -1, "These controls have validators that limit\n"
+ "the type of characters that can be entered."))
+
+ fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
+
+ label = wxStaticText(self, -1, "Alpha Only: ")
+ fgs.Add(label, 0, wxALIGN_RIGHT|wxCENTER)
+
+ fgs.Add(wxTextCtrl(self, -1, "", validator = MyValidator(ALPHA_ONLY))
+
+ fgs.Add(1,VSPACE); fgs.Add(1,VSPACE)
+
+ label = wxStaticText(self, -1, "Digits Only: ")
+ fgs.Add(label, 0, wxALIGN_RIGHT|wxCENTER)
+ fgs.Add(wxTextCtrl(self, -1, "", validator = MyValidator(DIGITS_ONLY)))
+
+ border = wxBoxSizer()
+ border.Add(fgs, 1, wxGROW|wxALL, 25)
+ self.SetSizer(border)
+ self.Layout()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestValidatorPanel(nb)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+overview = """\
+wxValidator is the base class for a family of validator classes that mediate between a class of control, and application data.
+
+A validator has three major roles:
+
+1. to transfer data from a C++ variable or own storage to and from a control;
+
+2. to validate data in a control, and show an appropriate error message;
+
+3. to filter events (such as keystrokes), thereby changing the behaviour of the associated control.
+
+Validators can be plugged into controls dynamically.
+
+"""
# This is really the wxPython version number, and will be placed in the
# Makefiles for use with the distribution related targets.
-__version__ = '2.1b3'
+__version__ = '2.1.4'
#----------------------------------------------------------------------------
runClean = runClean,
runUninstall = runUninstall)
+ err = 0
if config.readConfigFiles(args):
config.doFixups()
config.makeMakefile()
- err = 0
if config.runBuild:
cmd = "%s -f %s" % (config.MAKE, config.MAKEFILE)
print "Running:", cmd
err = os.system(cmd)
+ return err
#----------------------------------------------------------------------------
--- /dev/null
+#----------------------------------------------------------------------
+# Name: wxPython.lib.GridSizer
+# Purpose: An example sizer derived from the C++ wxPySizer that
+# sizes items in a fixed or flexible grid.
+#
+# Author: Robin Dunn
+#
+# Created: 21-Sept-1999
+# RCS-ID: $Id$
+# Copyright: (c) 1999 by Total Control Software
+# Licence: wxWindows license
+#----------------------------------------------------------------------
+
+"""
+
+In this module you will find wxGridSizer and wxFlexgridSizer.
+wxGridSizer arrainges its items in a grid in which all the widths and
+heights are the same. wxFlexgridSizer allows different widths and
+heights, and you can also specify rows and/or columns that are
+growable. See the demo for a couple examples for how to use them.
+
+"""
+
+
+from wxPython.wx import *
+
+import operator
+
+#----------------------------------------------------------------------
+
+class wxGridSizer(wxPySizer):
+ def __init__(self, rows=0, cols=0, hgap=0, vgap=0):
+ wxPySizer.__init__(self)
+ if rows == 0 and cols == 0:
+ raise ValueError, "rows and cols cannot both be zero"
+
+ self.rows = rows
+ self.cols = cols
+ self.hgap = hgap
+ self.vgap = vgap
+
+
+ def SetRows(self, rows):
+ if rows == 0 and self.cols == 0:
+ raise ValueError, "rows and cols cannot both be zero"
+ self.rows = rows
+
+ def SetColumns(self, cols):
+ if self.rows == 0 and cols == 0:
+ raise ValueError, "rows and cols cannot both be zero"
+ self.cols = cols
+
+ def GetRows(self):
+ return self.rows
+
+ def GetColumns(self):
+ return self.cols
+
+ def SetHgap(self, hgap):
+ self.hgap = hgap
+
+ def SetVgap(self, vgap):
+ self.vgap = vgap
+
+ def GetHgap(self, hgap):
+ return self.hgap
+
+ def GetVgap(self, vgap):
+ return self.vgap
+
+ #--------------------------------------------------
+ def CalcMin(self):
+ items = self.GetChildren()
+ nitems = len(items)
+ nrows = self.rows
+ ncols = self.cols
+
+ if ncols > 0:
+ nrows = (nitems + ncols-1) / ncols
+ else:
+ ncols = (nitems + nrows-1) / nrows
+
+ # Find the max width and height for any component.
+ w = 0
+ h = 0
+ for item in items:
+ size = item.CalcMin()
+ w = max(w, size.width)
+ h = max(h, size.height)
+
+ return wxSize(ncols * w + (ncols-1) * self.hgap,
+ nrows * h + (nrows-1) * self.vgap)
+
+
+ #--------------------------------------------------
+ def RecalcSizes(self):
+ items = self.GetChildren()
+ if not items:
+ return
+
+ nitems = len(items)
+ nrows = self.rows
+ ncols = self.cols
+
+ if ncols > 0:
+ nrows = (nitems + ncols-1) / ncols
+ else:
+ ncols = (nitems + nrows-1) / nrows
+
+
+ sz = self.GetSize()
+ pt = self.GetPosition()
+ w = (sz.width - (ncols - 1) * self.hgap) / ncols;
+ h = (sz.height - (nrows - 1) * self.vgap) / nrows;
+
+ x = pt.x
+ for c in range(ncols):
+ y = pt.y
+ for r in range(nrows):
+ i = r * ncols + c
+ if i < nitems:
+ self.SetItemBounds(items[i], x, y, w, h)
+ y = y + h + self.vgap
+ x = x + w + self.hgap
+
+
+ #--------------------------------------------------
+ def SetItemBounds(self, item, x, y, w, h):
+ # calculate the item's size and position within
+ # its grid cell
+ ipt = wxPoint(x, y)
+ isz = item.CalcMin()
+ flag = item.GetFlag()
+
+ if flag & wxEXPAND:
+ isz = wxSize(w, h)
+
+ elif flag & wxCENTER:
+ ipt.x = x + (w - isz.width) / 2
+ ipt.y = y + (h - isz.height) / 2
+
+ if flag & wxALIGN_LEFT:
+ ipt.x = x
+ elif flag & wxALIGN_RIGHT:
+ ipt.x = x + (w - isz.width)
+
+ if flag & wxALIGN_TOP:
+ ipt.y = y
+ elif flag & wxALIGN_BOTTOM:
+ ipt.y = y + (h - isz.height)
+
+ item.SetDimension(ipt, isz)
+
+
+#----------------------------------------------------------------------
+
+
+
+class wxFlexGridSizer(wxGridSizer):
+ def __init__(self, rows=0, cols=0, hgap=0, vgap=0):
+ wxGridSizer.__init__(self, rows, cols, hgap, vgap)
+ self.rowHeights = []
+ self.colWidths = []
+ self.growableRows = []
+ self.growableCols = []
+
+ def AddGrowableRow(self, idx):
+ self.growableRows.append(idx)
+
+ def AddGrowableCol(self, idx):
+ self.growableCols.append(idx)
+
+ #--------------------------------------------------
+ def CalcMin(self):
+ items = self.GetChildren()
+ nitems = len(items)
+ nrows = self.rows
+ ncols = self.cols
+
+ if ncols > 0:
+ nrows = (nitems + ncols-1) / ncols
+ else:
+ ncols = (nitems + nrows-1) / nrows
+
+ # Find the max width and height for any component.
+ self.rowHeights = [0] * nrows
+ self.colWidths = [0] * ncols
+ for i in range(len(items)):
+ size = items[i].CalcMin()
+ row = i / ncols
+ col = i % ncols
+ self.rowHeights[row] = max(size.height, self.rowHeights[row])
+ self.colWidths[col] = max(size.width, self.colWidths[col])
+
+ # Add up all the widths and heights
+ cellsWidth = reduce(operator.__add__, self.colWidths)
+ cellHeight = reduce(operator.__add__, self.rowHeights)
+
+ return wxSize(cellsWidth + (ncols-1) * self.hgap,
+ cellHeight + (nrows-1) * self.vgap)
+
+
+ #--------------------------------------------------
+ def RecalcSizes(self):
+ items = self.GetChildren()
+ if not items:
+ return
+
+ nitems = len(items)
+ nrows = self.rows
+ ncols = self.cols
+
+ if ncols > 0:
+ nrows = (nitems + ncols-1) / ncols
+ else:
+ ncols = (nitems + nrows-1) / nrows
+
+ minsz = self.CalcMin()
+ sz = self.GetSize()
+ pt = self.GetPosition()
+
+ # Check for growables
+ if self.growableRows and sz.height > minsz.height:
+ delta = (sz.height - minsz.height) / len(self.growableRows)
+ for idx in self.growableRows:
+ self.rowHeights[idx] = self.rowHeights[idx] + delta
+
+ if self.growableCols and sz.width > minsz.width:
+ delta = (sz.width - minsz.width) / len(self.growableCols)
+ for idx in self.growableCols:
+ self.colWidths[idx] = self.colWidths[idx] + delta
+
+ # Layout each cell
+ x = pt.x
+ for c in range(ncols):
+ y = pt.y
+ for r in range(nrows):
+ i = r * ncols + c
+ if i < nitems:
+ w = max(0, min(self.colWidths[c], sz.width - x))
+ h = max(0, min(self.rowHeights[r], sz.height - y))
+ self.SetItemBounds(items[i], x, y, w, h)
+ y = y + self.rowHeights[r] + self.vgap
+ x = x + self.colWidths[c] + self.hgap
+
+#----------------------------------------------------------------------
+
+
+
+
+
+
from border import *
#----------------------------------------------------------------------------
+
+import os
+from wxPython.wx import wxMessageDialog, wxOK, wxICON_EXCLAMATION
+
+if not os.environ.has_key('WXP_OLDSIZERS'):
+ dlg = wxMessageDialog(None,
+ "Since wxWindows now includes sizers the classes in\n"
+ "wxPython.lib.sizers have been depreciated. Please\n"
+ "see the Reference Manual for details of the new classes.\n"
+ "\n"
+ "To contiunue using wxPython.lib.sizers without this\n"
+ "message you can set the WXP_OLDSIZERS envronment \n"
+ "variable to any value.",
+ "Depreciated Feature",
+ wxOK | wxICON_EXCLAMATION)
+ dlg.ShowModal()
+ dlg.Destroy()
+
+#----------------------------------------------------------------------------
sys.path.insert(0, '../distrib')
import build
-MODULELIST = ['html', 'glcanvas', 'utils', 'ogl', 'lseditor']
+MODULELIST = ['html', 'glcanvas', 'utils', 'ogl', ] #'lseditor']
for module in MODULELIST:
cwd = os.getcwd()
- print "**** Building %s" % module
- build.main([sys.argv[0], '-C', module] + sys.argv[1:])
+ print "**** Building %s ****" % module
+ err = build.main([sys.argv[0], '-C', module] + sys.argv[1:])
os.chdir(cwd)
+ if err:
+ break
+
# -*- python -*-
MODULE = 'htmlc'
-SWIGFILES = ['html.i', ] #'htmlhelp.i' ]
-PYFILES = ['htmlhelper.py']
+SWIGFILES = ['html.i', 'htmlhelp.i' ]
+
+#PYFILES = ['htmlhelper.py']
#SOURCES = ['helpsys.cpp']
OTHERSWIGFLAGS = '-I../utils'
#include <wx/fs_zip.h>
#include <wx/fs_inet.h>
#include <wx/wfstream.h>
-#include "helpsys.h"
static PyObject* l_output_helper(PyObject* target, PyObject* o) {
PyObject* o2;
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __WXMSW__
int _arg4 = (int ) wxHW_SCROLLBAR_AUTO;
char * _arg5 = (char *) "htmlWindow";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","flags","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOis:new_wxHtmlWindow",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOis:new_wxHtmlWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxHtmlWindow. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxHtmlWindow. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxPyHtmlWindow *)new_wxHtmlWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
{ "_class_wxJPEGHandler","_wxJPEGHandler",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxBMPHandler","_class_wxBMPHandler",0},
{ "_wxImage","_class_wxImage",0},
{ "_wxPrintQuality","_int",0},
{ "_class_wxRegionIterator","_wxRegionIterator",0},
{ "_class_wxMenuBar","_wxMenuBar",0},
{ "_class_wxPyTreeItemData","_wxPyTreeItemData",0},
+ { "_class_wxStaticBoxSizer","_wxStaticBoxSizer",0},
{ "_class_wxEvtHandler","_class_wxPyHtmlWindow",SwigwxPyHtmlWindowTowxEvtHandler},
{ "_class_wxEvtHandler","_wxPyHtmlWindow",SwigwxPyHtmlWindowTowxEvtHandler},
{ "_class_wxEvtHandler","_wxEvtHandler",0},
{ "_wxPaintEvent","_class_wxPaintEvent",0},
{ "_wxGIFHandler","_class_wxGIFHandler",0},
+ { "_wxPySizer","_class_wxPySizer",0},
{ "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
{ "_wxCursor","_class_wxCursor",0},
{ "_wxNotifyEvent","_class_wxNotifyEvent",0},
{ "_wxDropFilesEvent","_class_wxDropFilesEvent",0},
{ "_wxBitmapButton","_class_wxBitmapButton",0},
{ "_wxSashWindow","_class_wxSashWindow",0},
+ { "_class_wxSizer","_wxSizer",0},
{ "_class_wxPrintDialogData","_wxPrintDialogData",0},
{ "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
{ "_class_wxGauge","_wxGauge",0},
{ "_class_wxSashEvent","_wxSashEvent",0},
{ "_wxDC","_class_wxDC",0},
+ { "_wxSizerItem","_class_wxSizerItem",0},
{ "_wxListEvent","_class_wxListEvent",0},
{ "_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0},
{ "_wxProgressDialog","_class_wxProgressDialog",0},
{ "_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0},
{ "_class_wxStatusBar","_wxStatusBar",0},
{ "_class_wxGIFHandler","_wxGIFHandler",0},
+ { "_class_wxPySizer","_wxPySizer",0},
{ "_class_wxPostScriptDC","_wxPostScriptDC",0},
{ "_wxPanel","_class_wxPyHtmlWindow",SwigwxPyHtmlWindowTowxPanel},
{ "_wxPanel","_wxPyHtmlWindow",SwigwxPyHtmlWindowTowxPanel},
{ "_class_wxButton","_wxButton",0},
{ "_wxRadioBox","_class_wxRadioBox",0},
{ "_class_wxFontData","_wxFontData",0},
+ { "_wxBoxSizer","_class_wxBoxSizer",0},
{ "_class___wxPyCleanup","___wxPyCleanup",0},
{ "_wxHtmlCell","_class_wxHtmlWidgetCell",SwigwxHtmlWidgetCellTowxHtmlCell},
{ "_wxHtmlCell","_wxHtmlWidgetCell",SwigwxHtmlWidgetCellTowxHtmlCell},
{ "_wxRealPoint","_class_wxRealPoint",0},
{ "_class_wxRadioBox","_wxRadioBox",0},
{ "_wxGridCell","_class_wxGridCell",0},
+ { "_class_wxBoxSizer","_wxBoxSizer",0},
{ "_class_wxHtmlWinParser","_wxHtmlWinParser",0},
{ "_class_wxHtmlCell","_class_wxHtmlWidgetCell",SwigwxHtmlWidgetCellTowxHtmlCell},
{ "_class_wxHtmlCell","_wxHtmlWidgetCell",SwigwxHtmlWidgetCellTowxHtmlCell},
{ "_wxWindowID","_signed_int",0},
{ "_wxWindowID","_unsigned_int",0},
{ "_class_wxScrollWinEvent","_wxScrollWinEvent",0},
+ { "_class_wxSizerItem","_wxSizerItem",0},
{ "_int","_wxPrintQuality",0},
{ "_int","_size_t",0},
{ "_int","_EBool",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxListEvent","_wxListEvent",0},
{ "_class_wxPrintPreview","_wxPrintPreview",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxRegionIterator","_class_wxRegionIterator",0},
{ "_class_wxMDIParentFrame","_wxMDIParentFrame",0},
{ "_wxPyTreeItemData","_class_wxPyTreeItemData",0},
+ { "_wxStaticBoxSizer","_class_wxStaticBoxSizer",0},
{ "_class_wxPaintDC","_wxPaintDC",0},
{ "_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_wxRegion","_class_wxRegion",0},
{ "_class_wxSplitterWindow","_wxSplitterWindow",0},
{ "_wxPreviewFrame","_class_wxPreviewFrame",0},
+ { "_wxSizer","_class_wxSizer",0},
{ "_class_wxShowEvent","_wxShowEvent",0},
{ "_wxActivateEvent","_class_wxActivateEvent",0},
{ "_wxGauge","_class_wxGauge",0},
mod_dict = d;
#endif
- //inithtmlhelpc();
+ inithtmlhelpc();
wxClassInfo::CleanUpClasses();
wxClassInfo::InitializeClasses();
#include <wx/fs_zip.h>
#include <wx/fs_inet.h>
#include <wx/wfstream.h>
-#include "helpsys.h"
%}
//---------------------------------------------------------------------------
#endif
%}
-%pragma(python) code = "import wx,htmlhelper"
+%pragma(python) code = "import wx"
%pragma(python) code = "widget = htmlc"
%{
bool SetPage(const char* source);
- // Set HTML page and display it. !! source is HTML document itself,
- // it is NOT address/filename of HTML document. If you want to
- // specify document location, use LoadPage() istead
- // Return value : FALSE if an error occured, TRUE otherwise
-
bool LoadPage(const char* location);
- // Load HTML page from given location. Location can be either
- // a) /usr/wxGTK2/docs/html/wx.htm
- // b) http://www.somewhere.uk/document.htm
- // c) ftp://ftp.somesite.cz/pub/something.htm
- // In case there is no prefix (http:,ftp:), the method
- // will try to find it itself (1. local file, then http or ftp)
- // After the page is loaded, the method calls SetPage() to display it.
- // Note : you can also use path relative to previously loaded page
- // Return value : same as SetPage
-
wxString GetOpenedPage();
- // Returns full location of opened page
-
void SetRelatedFrame(wxFrame* frame, const char* format);
- // sets frame in which page title will be displayed. Format is format of
- // frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s
wxFrame* GetRelatedFrame();
-
void SetRelatedStatusBar(int bar);
- // after(!) calling SetRelatedFrame, this sets statusbar slot where messages
- // will be displayed. Default is -1 = no messages.
-
void SetFonts(wxString normal_face, int normal_italic_mode,
wxString fixed_face, int fixed_italic_mode, int *LIST);
- // sets fonts to be used when displaying HTML page.
- // *_italic_mode can be either wxSLANT or wxITALIC
-
void SetTitle(const char* title);
- // Sets the title of the window
- // (depending on the information passed to SetRelatedFrame() method)
-
void SetBorders(int b);
- // Sets space between text and window borders.
-
void ReadCustomization(wxConfigBase *cfg, char* path = "");
- // saves custom settings into cfg config. it will use the path 'path'
- // if given, otherwise it will save info into currently selected path.
- // saved values : things set by SetFonts, SetBorders.
-
void WriteCustomization(wxConfigBase *cfg, char* path = "");
- // ...
-
bool HistoryBack();
bool HistoryForward();
- // Goes to previous/next page (in browsing history)
- // Returns TRUE if successful, FALSE otherwise
void HistoryClear();
- // Resets history
-
wxHtmlContainerCell* GetInternalRepresentation();
- // Returns pointer to conteiners/cells structure.
- // It should be used ONLY when printing
-
wxHtmlWinParser* GetParser();
void base_OnLinkClicked(const char* link);
- // called when users clicked on hypertext link. Default behavior is to
- // call LoadPage(loc)
-
};
// Static methods are mapped to stand-alone functions
mod_dict = d;
#endif
- //inithtmlhelpc();
+ inithtmlhelpc();
wxClassInfo::CleanUpClasses();
wxClassInfo::InitializeClasses();
from image import *
from printfw import *
-import wx,htmlhelper
+
+from sizers import *
+import wx
widget = htmlc
class wxHtmlTagPtr :
def __init__(self,this):
--- /dev/null
+/*
+ * FILE : ./htmlhelp.cpp
+ *
+ * This file was automatically generated by :
+ * Simplified Wrapper and Interface Generator (SWIG)
+ * Version 1.1 (Build 810)
+ *
+ * Portions Copyright (c) 1995-1998
+ * The University of Utah and The Regents of the University of California.
+ * Permission is granted to distribute this file in any manner provided
+ * this notice remains intact.
+ *
+ * Do not make changes to this file--changes will be lost!
+ *
+ */
+
+
+#define SWIGCODE
+/* Implementation : PYTHON */
+
+#define SWIGPYTHON
+#include <string.h>
+#include <stdlib.h>
+/* Definitions for Windows/Unix exporting */
+#if defined(__WIN32__)
+# if defined(_MSC_VER)
+# define SWIGEXPORT(a) __declspec(dllexport) a
+# else
+# if defined(__BORLANDC__)
+# define SWIGEXPORT(a) a _export
+# else
+# define SWIGEXPORT(a) a
+# endif
+# endif
+#else
+# define SWIGEXPORT(a) a
+#endif
+
+#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 char *SWIG_GetPtrObj(PyObject *, void **, char *);
+extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
+extern PyObject *SWIG_newvarlink(void);
+#ifdef __cplusplus
+}
+#endif
+#define SWIG_init inithtmlhelpc
+
+#define SWIG_name "htmlhelpc"
+
+#include "helpers.h"
+#include <wx/html/htmlwin.h>
+#include <wx/html/helpctrl.h>
+#include <wx/image.h>
+#include <wx/fs_zip.h>
+#include <wx/fs_inet.h>
+#include <wx/wfstream.h>
+
+static PyObject* l_output_helper(PyObject* target, PyObject* o) {
+ PyObject* o2;
+ PyObject* o3;
+ if (!target) {
+ target = o;
+ } else if (target == Py_None) {
+ Py_DECREF(Py_None);
+ target = o;
+ } else {
+ if (!PyList_Check(target)) {
+ o2 = target;
+ target = PyList_New(0);
+ PyList_Append(target, o2);
+ Py_XDECREF(o2);
+ }
+ PyList_Append(target,o);
+ Py_XDECREF(o);
+ }
+ return target;
+}
+
+static PyObject* t_output_helper(PyObject* target, PyObject* o) {
+ PyObject* o2;
+ PyObject* o3;
+
+ if (!target) {
+ target = o;
+ } else if (target == Py_None) {
+ Py_DECREF(Py_None);
+ target = o;
+ } else {
+ if (!PyTuple_Check(target)) {
+ o2 = target;
+ target = PyTuple_New(1);
+ PyTuple_SetItem(target, 0, o2);
+ }
+ o3 = PyTuple_New(1);
+ PyTuple_SetItem(o3, 0, o);
+
+ o2 = target;
+ target = PySequence_Concat(o2, o3);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ }
+ return target;
+}
+
+static char* wxStringErrorMsg = "string type is required for parameter";
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define new_wxHtmlHelpFrameCfg() (new wxHtmlHelpFrameCfg())
+static PyObject *_wrap_new_wxHtmlHelpFrameCfg(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrameCfg * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxHtmlHelpFrameCfg",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlHelpFrameCfg *)new_wxHtmlHelpFrameCfg();
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlHelpFrameCfg_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_x_set(_swigobj,_swigval) (_swigobj->x = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_x_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ long _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","x", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxHtmlHelpFrameCfg_x_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_x_set. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_x_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_x_get(_swigobj) ((long ) _swigobj->x)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_x_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_x_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_x_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_x_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_y_set(_swigobj,_swigval) (_swigobj->y = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_y_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ long _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","y", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxHtmlHelpFrameCfg_y_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_y_set. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_y_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_y_get(_swigobj) ((long ) _swigobj->y)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_y_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_y_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_y_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_y_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_w_set(_swigobj,_swigval) (_swigobj->w = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_w_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ long _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","w", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxHtmlHelpFrameCfg_w_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_w_set. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_w_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_w_get(_swigobj) ((long ) _swigobj->w)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_w_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_w_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_w_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_w_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_h_set(_swigobj,_swigval) (_swigobj->h = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_h_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ long _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","h", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxHtmlHelpFrameCfg_h_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_h_set. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_h_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_h_get(_swigobj) ((long ) _swigobj->h)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_h_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_h_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_h_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_h_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_sashpos_set(_swigobj,_swigval) (_swigobj->sashpos = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_sashpos_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ long _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","sashpos", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxHtmlHelpFrameCfg_sashpos_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_sashpos_set. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_sashpos_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_sashpos_get(_swigobj) ((long ) _swigobj->sashpos)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_sashpos_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ long _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_sashpos_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_sashpos_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (long )wxHtmlHelpFrameCfg_sashpos_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("l",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_navig_on_set(_swigobj,_swigval) (_swigobj->navig_on = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_navig_on_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ bool _arg1;
+ PyObject * _argo0 = 0;
+ int tempbool1;
+ char *_kwnames[] = { "self","navig_on", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxHtmlHelpFrameCfg_navig_on_set",_kwnames,&_argo0,&tempbool1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_navig_on_set. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+ _arg1 = (bool ) tempbool1;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxHtmlHelpFrameCfg_navig_on_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_navig_on_get(_swigobj) ((bool ) _swigobj->navig_on)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_navig_on_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_navig_on_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_navig_on_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxHtmlHelpFrameCfg_navig_on_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_style_set(_swigobj,_swigval) (_swigobj->style = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_style_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ int _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","style", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxHtmlHelpFrameCfg_style_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_style_set. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlHelpFrameCfg_style_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_style_get(_swigobj) ((int ) _swigobj->style)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_style_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_style_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_style_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlHelpFrameCfg_style_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_titleformat_set(_swigobj,_swigval) (_swigobj->titleformat = *(_swigval),_swigval)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_titleformat_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","titleformat", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpFrameCfg_titleformat_set",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_titleformat_set. Expected _wxHtmlHelpFrameCfg_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 = (wxString *)wxHtmlHelpFrameCfg_titleformat_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST (*_result));
+}
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrameCfg_titleformat_get(_swigobj) (&_swigobj->titleformat)
+static PyObject *_wrap_wxHtmlHelpFrameCfg_titleformat_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlHelpFrameCfg * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrameCfg_titleformat_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrameCfg_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrameCfg_titleformat_get. Expected _wxHtmlHelpFrameCfg_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxString *)wxHtmlHelpFrameCfg_titleformat_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST (*_result));
+}
+ return _resultobj;
+}
+
+#define new_wxHtmlBookRecord(_swigarg0,_swigarg1,_swigarg2) (new wxHtmlBookRecord(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_new_wxHtmlBookRecord(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlBookRecord * _result;
+ wxString * _arg0;
+ wxString * _arg1;
+ wxString * _arg2;
+ PyObject * _obj0 = 0;
+ PyObject * _obj1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "basepath","title","start", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:new_wxHtmlBookRecord",_kwnames,&_obj0,&_obj1,&_obj2))
+ 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));
+}
+{
+ 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 = (wxHtmlBookRecord *)new_wxHtmlBookRecord(*_arg0,*_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlBookRecord_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+{
+ if (_obj0)
+ delete _arg0;
+}
+{
+ if (_obj1)
+ delete _arg1;
+}
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxHtmlBookRecord_GetTitle(_swigobj) (_swigobj->GetTitle())
+static PyObject *_wrap_wxHtmlBookRecord_GetTitle(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlBookRecord * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlBookRecord_GetTitle",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlBookRecord_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlBookRecord_GetTitle. Expected _wxHtmlBookRecord_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxString (wxHtmlBookRecord_GetTitle(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST *(_result));
+}
+{
+ delete _result;
+}
+ return _resultobj;
+}
+
+#define wxHtmlBookRecord_GetStart(_swigobj) (_swigobj->GetStart())
+static PyObject *_wrap_wxHtmlBookRecord_GetStart(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlBookRecord * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlBookRecord_GetStart",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlBookRecord_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlBookRecord_GetStart. Expected _wxHtmlBookRecord_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxString (wxHtmlBookRecord_GetStart(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST *(_result));
+}
+{
+ delete _result;
+}
+ return _resultobj;
+}
+
+#define wxHtmlBookRecord_GetBasePath(_swigobj) (_swigobj->GetBasePath())
+static PyObject *_wrap_wxHtmlBookRecord_GetBasePath(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlBookRecord * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlBookRecord_GetBasePath",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlBookRecord_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlBookRecord_GetBasePath. Expected _wxHtmlBookRecord_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxString (wxHtmlBookRecord_GetBasePath(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST *(_result));
+}
+{
+ delete _result;
+}
+ return _resultobj;
+}
+
+#define wxHtmlBookRecord_SetContentsRange(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetContentsRange(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlBookRecord_SetContentsRange(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlBookRecord * _arg0;
+ int _arg1;
+ int _arg2;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","start","end", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxHtmlBookRecord_SetContentsRange",_kwnames,&_argo0,&_arg1,&_arg2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlBookRecord_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlBookRecord_SetContentsRange. Expected _wxHtmlBookRecord_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlBookRecord_SetContentsRange(_arg0,_arg1,_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlBookRecord_GetContentsStart(_swigobj) (_swigobj->GetContentsStart())
+static PyObject *_wrap_wxHtmlBookRecord_GetContentsStart(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlBookRecord * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlBookRecord_GetContentsStart",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlBookRecord_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlBookRecord_GetContentsStart. Expected _wxHtmlBookRecord_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlBookRecord_GetContentsStart(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlBookRecord_GetContentsEnd(_swigobj) (_swigobj->GetContentsEnd())
+static PyObject *_wrap_wxHtmlBookRecord_GetContentsEnd(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlBookRecord * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlBookRecord_GetContentsEnd",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlBookRecord_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlBookRecord_GetContentsEnd. Expected _wxHtmlBookRecord_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlBookRecord_GetContentsEnd(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_Level_set(_swigobj,_swigval) (_swigobj->m_Level = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlContentsItem_m_Level_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ short _result;
+ wxHtmlContentsItem * _arg0;
+ short _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","m_Level", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oh:wxHtmlContentsItem_m_Level_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Level_set. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (short )wxHtmlContentsItem_m_Level_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("h",_result);
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_Level_get(_swigobj) ((short ) _swigobj->m_Level)
+static PyObject *_wrap_wxHtmlContentsItem_m_Level_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ short _result;
+ wxHtmlContentsItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlContentsItem_m_Level_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Level_get. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (short )wxHtmlContentsItem_m_Level_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("h",_result);
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_ID_set(_swigobj,_swigval) (_swigobj->m_ID = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlContentsItem_m_ID_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlContentsItem * _arg0;
+ int _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","m_ID", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxHtmlContentsItem_m_ID_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_ID_set. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlContentsItem_m_ID_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_ID_get(_swigobj) ((int ) _swigobj->m_ID)
+static PyObject *_wrap_wxHtmlContentsItem_m_ID_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlContentsItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlContentsItem_m_ID_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_ID_get. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlContentsItem_m_ID_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+static char * wxHtmlContentsItem_m_Name_set(wxHtmlContentsItem *obj, char *val) {
+ if (obj->m_Name) delete [] obj->m_Name;
+ obj->m_Name = new char[strlen(val)+1];
+ strcpy((char *)obj->m_Name,val);
+ return (char *) val;
+}
+static PyObject *_wrap_wxHtmlContentsItem_m_Name_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ char * _result;
+ wxHtmlContentsItem * _arg0;
+ char * _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","m_Name", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os:wxHtmlContentsItem_m_Name_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Name_set. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (char *)wxHtmlContentsItem_m_Name_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("s", _result);
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_Name_get(_swigobj) ((char *) _swigobj->m_Name)
+static PyObject *_wrap_wxHtmlContentsItem_m_Name_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ char * _result;
+ wxHtmlContentsItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlContentsItem_m_Name_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Name_get. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (char *)wxHtmlContentsItem_m_Name_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("s", _result);
+ return _resultobj;
+}
+
+static char * wxHtmlContentsItem_m_Page_set(wxHtmlContentsItem *obj, char *val) {
+ if (obj->m_Page) delete [] obj->m_Page;
+ obj->m_Page = new char[strlen(val)+1];
+ strcpy((char *)obj->m_Page,val);
+ return (char *) val;
+}
+static PyObject *_wrap_wxHtmlContentsItem_m_Page_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ char * _result;
+ wxHtmlContentsItem * _arg0;
+ char * _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","m_Page", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os:wxHtmlContentsItem_m_Page_set",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Page_set. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (char *)wxHtmlContentsItem_m_Page_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("s", _result);
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_Page_get(_swigobj) ((char *) _swigobj->m_Page)
+static PyObject *_wrap_wxHtmlContentsItem_m_Page_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ char * _result;
+ wxHtmlContentsItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlContentsItem_m_Page_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Page_get. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (char *)wxHtmlContentsItem_m_Page_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("s", _result);
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_Book_set(_swigobj,_swigval) (_swigobj->m_Book = _swigval,_swigval)
+static PyObject *_wrap_wxHtmlContentsItem_m_Book_set(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlBookRecord * _result;
+ wxHtmlContentsItem * _arg0;
+ wxHtmlBookRecord * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","m_Book", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlContentsItem_m_Book_set",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Book_set. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxHtmlBookRecord_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxHtmlContentsItem_m_Book_set. Expected _wxHtmlBookRecord_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlBookRecord *)wxHtmlContentsItem_m_Book_set(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlBookRecord_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlContentsItem_m_Book_get(_swigobj) ((wxHtmlBookRecord *) _swigobj->m_Book)
+static PyObject *_wrap_wxHtmlContentsItem_m_Book_get(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlBookRecord * _result;
+ wxHtmlContentsItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlContentsItem_m_Book_get",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlContentsItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlContentsItem_m_Book_get. Expected _wxHtmlContentsItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlBookRecord *)wxHtmlContentsItem_m_Book_get(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlBookRecord_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlSearchStatus_Search(_swigobj) (_swigobj->Search())
+static PyObject *_wrap_wxHtmlSearchStatus_Search(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlSearchStatus * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlSearchStatus_Search",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlSearchStatus_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlSearchStatus_Search. Expected _wxHtmlSearchStatus_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxHtmlSearchStatus_Search(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlSearchStatus_IsActive(_swigobj) (_swigobj->IsActive())
+static PyObject *_wrap_wxHtmlSearchStatus_IsActive(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlSearchStatus * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlSearchStatus_IsActive",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlSearchStatus_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlSearchStatus_IsActive. Expected _wxHtmlSearchStatus_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxHtmlSearchStatus_IsActive(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlSearchStatus_GetCurIndex(_swigobj) (_swigobj->GetCurIndex())
+static PyObject *_wrap_wxHtmlSearchStatus_GetCurIndex(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlSearchStatus * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlSearchStatus_GetCurIndex",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlSearchStatus_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlSearchStatus_GetCurIndex. Expected _wxHtmlSearchStatus_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlSearchStatus_GetCurIndex(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlSearchStatus_GetMaxIndex(_swigobj) (_swigobj->GetMaxIndex())
+static PyObject *_wrap_wxHtmlSearchStatus_GetMaxIndex(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlSearchStatus * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlSearchStatus_GetMaxIndex",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlSearchStatus_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlSearchStatus_GetMaxIndex. Expected _wxHtmlSearchStatus_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlSearchStatus_GetMaxIndex(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlSearchStatus_GetName(_swigobj) (_swigobj->GetName())
+static PyObject *_wrap_wxHtmlSearchStatus_GetName(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlSearchStatus * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlSearchStatus_GetName",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlSearchStatus_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlSearchStatus_GetName. Expected _wxHtmlSearchStatus_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ const wxString & _result_ref = wxHtmlSearchStatus_GetName(_arg0);
+ _result = (wxString *) &_result_ref;
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST (*_result));
+}
+ return _resultobj;
+}
+
+#define wxHtmlSearchStatus_GetContentsItem(_swigobj) (_swigobj->GetContentsItem())
+static PyObject *_wrap_wxHtmlSearchStatus_GetContentsItem(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlContentsItem * _result;
+ wxHtmlSearchStatus * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlSearchStatus_GetContentsItem",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlSearchStatus_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlSearchStatus_GetContentsItem. Expected _wxHtmlSearchStatus_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlContentsItem *)wxHtmlSearchStatus_GetContentsItem(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlContentsItem_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define new_wxHtmlHelpData() (new wxHtmlHelpData())
+static PyObject *_wrap_new_wxHtmlHelpData(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpData * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxHtmlHelpData",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlHelpData *)new_wxHtmlHelpData();
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlHelpData_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define delete_wxHtmlHelpData(_swigobj) (delete _swigobj)
+static PyObject *_wrap_delete_wxHtmlHelpData(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpData * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxHtmlHelpData",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxHtmlHelpData. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ delete_wxHtmlHelpData(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_SetTempDir(_swigobj,_swigarg0) (_swigobj->SetTempDir(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpData_SetTempDir(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpData * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpData_SetTempDir",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_SetTempDir. Expected _wxHtmlHelpData_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;
+ wxHtmlHelpData_SetTempDir(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_AddBook(_swigobj,_swigarg0) (_swigobj->AddBook(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpData_AddBook(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlHelpData * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","book", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpData_AddBook",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_AddBook. Expected _wxHtmlHelpData_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 )wxHtmlHelpData_AddBook(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_AddBookParam(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (_swigobj->AddBookParam(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_wxHtmlHelpData_AddBookParam(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlHelpData * _arg0;
+ wxString * _arg1;
+ wxString * _arg2;
+ wxString * _arg3 = (wxString *) &wxEmptyString;
+ wxString * _arg4 = (wxString *) &wxEmptyString;
+ wxString * _arg5 = (wxString *) &wxEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ PyObject * _obj2 = 0;
+ PyObject * _obj3 = 0;
+ PyObject * _obj4 = 0;
+ PyObject * _obj5 = 0;
+ char *_kwnames[] = { "self","title","contfile","indexfile","deftopic","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|OOO:wxHtmlHelpData_AddBookParam",_kwnames,&_argo0,&_obj1,&_obj2,&_obj3,&_obj4,&_obj5))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_AddBookParam. Expected _wxHtmlHelpData_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));
+}
+ if (_obj3)
+{
+ if (!PyString_Check(_obj3)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg3 = new wxString(PyString_AsString(_obj3), PyString_Size(_obj3));
+}
+ if (_obj4)
+{
+ if (!PyString_Check(_obj4)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg4 = new wxString(PyString_AsString(_obj4), PyString_Size(_obj4));
+}
+ if (_obj5)
+{
+ if (!PyString_Check(_obj5)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg5 = new wxString(PyString_AsString(_obj5), PyString_Size(_obj5));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxHtmlHelpData_AddBookParam(_arg0,*_arg1,*_arg2,*_arg3,*_arg4,*_arg5);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (_obj1)
+ delete _arg1;
+}
+{
+ if (_obj2)
+ delete _arg2;
+}
+{
+ if (_obj3)
+ delete _arg3;
+}
+{
+ if (_obj4)
+ delete _arg4;
+}
+{
+ if (_obj5)
+ delete _arg5;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_FindPageByName(_swigobj,_swigarg0) (_swigobj->FindPageByName(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpData_FindPageByName(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlHelpData * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","page", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpData_FindPageByName",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_FindPageByName. Expected _wxHtmlHelpData_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 = new wxString (wxHtmlHelpData_FindPageByName(_arg0,*_arg1));
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST *(_result));
+}
+{
+ if (_obj1)
+ delete _arg1;
+}
+{
+ delete _result;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_FindPageById(_swigobj,_swigarg0) (_swigobj->FindPageById(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpData_FindPageById(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxString * _result;
+ wxHtmlHelpData * _arg0;
+ int _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","id", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxHtmlHelpData_FindPageById",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_FindPageById. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxString (wxHtmlHelpData_FindPageById(_arg0,_arg1));
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = PyString_FromString(WXSTRINGCAST *(_result));
+}
+{
+ delete _result;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_GetBookRecArray(_swigobj) (_swigobj->GetBookRecArray())
+static PyObject *_wrap_wxHtmlHelpData_GetBookRecArray(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlBookRecArray * _result;
+ wxHtmlHelpData * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpData_GetBookRecArray",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_GetBookRecArray. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ const wxHtmlBookRecArray & _result_ref = wxHtmlHelpData_GetBookRecArray(_arg0);
+ _result = (wxHtmlBookRecArray *) &_result_ref;
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlBookRecArray_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_GetContents(_swigobj) (_swigobj->GetContents())
+static PyObject *_wrap_wxHtmlHelpData_GetContents(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlContentsItem * _result;
+ wxHtmlHelpData * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpData_GetContents",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_GetContents. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlContentsItem *)wxHtmlHelpData_GetContents(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlContentsItem_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_GetContentsCnt(_swigobj) (_swigobj->GetContentsCnt())
+static PyObject *_wrap_wxHtmlHelpData_GetContentsCnt(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlHelpData * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpData_GetContentsCnt",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_GetContentsCnt. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlHelpData_GetContentsCnt(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_GetIndex(_swigobj) (_swigobj->GetIndex())
+static PyObject *_wrap_wxHtmlHelpData_GetIndex(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlContentsItem * _result;
+ wxHtmlHelpData * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpData_GetIndex",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_GetIndex. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlContentsItem *)wxHtmlHelpData_GetIndex(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlContentsItem_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlHelpData_GetIndexCnt(_swigobj) (_swigobj->GetIndexCnt())
+static PyObject *_wrap_wxHtmlHelpData_GetIndexCnt(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxHtmlHelpData * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpData_GetIndexCnt",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpData_GetIndexCnt. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxHtmlHelpData_GetIndexCnt(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+static void *SwigwxHtmlHelpFrameTowxFrame(void *ptr) {
+ wxHtmlHelpFrame *src;
+ wxFrame *dest;
+ src = (wxHtmlHelpFrame *) ptr;
+ dest = (wxFrame *) src;
+ return (void *) dest;
+}
+
+static void *SwigwxHtmlHelpFrameTowxWindow(void *ptr) {
+ wxHtmlHelpFrame *src;
+ wxWindow *dest;
+ src = (wxHtmlHelpFrame *) ptr;
+ dest = (wxWindow *) src;
+ return (void *) dest;
+}
+
+static void *SwigwxHtmlHelpFrameTowxEvtHandler(void *ptr) {
+ wxHtmlHelpFrame *src;
+ wxEvtHandler *dest;
+ src = (wxHtmlHelpFrame *) ptr;
+ dest = (wxEvtHandler *) src;
+ return (void *) dest;
+}
+
+#define new_wxHtmlHelpFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxHtmlHelpFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_new_wxHtmlHelpFrame(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _result;
+ wxWindow * _arg0;
+ int _arg1;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ int _arg3 = (int ) wxHF_DEFAULTSTYLE;
+ wxHtmlHelpData * _arg4 = (wxHtmlHelpData *) NULL;
+ PyObject * _argo0 = 0;
+ PyObject * _obj2 = 0;
+ PyObject * _argo4 = 0;
+ char *_kwnames[] = { "parent","wxWindowID","title","style","data", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OiO:new_wxHtmlHelpFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_arg3,&_argo4))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxHtmlHelpFrame. Expected _wxWindow_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 (_argo4) {
+ if (_argo4 == Py_None) { _arg4 = NULL; }
+ else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxHtmlHelpData_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxHtmlHelpFrame. Expected _wxHtmlHelpData_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlHelpFrame *)new_wxHtmlHelpFrame(_arg0,_arg1,*_arg2,_arg3,_arg4);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlHelpFrame_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_GetData(_swigobj) (_swigobj->GetData())
+static PyObject *_wrap_wxHtmlHelpFrame_GetData(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpData * _result;
+ wxHtmlHelpFrame * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrame_GetData",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_GetData. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlHelpData *)wxHtmlHelpFrame_GetData(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlHelpData_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_SetTitleFormat(_swigobj,_swigarg0) (_swigobj->SetTitleFormat(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpFrame_SetTitleFormat(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","format", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpFrame_SetTitleFormat",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_SetTitleFormat. Expected _wxHtmlHelpFrame_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;
+ wxHtmlHelpFrame_SetTitleFormat(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_Display(_swigobj,_swigarg0) (_swigobj->Display(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpFrame_Display(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","x", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpFrame_Display",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_Display. Expected _wxHtmlHelpFrame_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;
+ wxHtmlHelpFrame_Display(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_DisplayID(_swigobj,_swigarg0) (_swigobj->Display(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpFrame_DisplayID(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ int _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","id", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxHtmlHelpFrame_DisplayID",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_DisplayID. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_DisplayID(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_DisplayContents(_swigobj) (_swigobj->DisplayContents())
+static PyObject *_wrap_wxHtmlHelpFrame_DisplayContents(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrame_DisplayContents",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_DisplayContents. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_DisplayContents(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_DisplayIndex(_swigobj) (_swigobj->DisplayIndex())
+static PyObject *_wrap_wxHtmlHelpFrame_DisplayIndex(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrame_DisplayIndex",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_DisplayIndex. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_DisplayIndex(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_KeywordSearch(_swigobj,_swigarg0) (_swigobj->KeywordSearch(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpFrame_KeywordSearch(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlHelpFrame * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","keyword", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpFrame_KeywordSearch",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_KeywordSearch. Expected _wxHtmlHelpFrame_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 )wxHtmlHelpFrame_KeywordSearch(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_RefreshLists(_swigobj,_swigarg0) (_swigobj->RefreshLists(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpFrame_RefreshLists(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ int _arg1 = (int ) FALSE;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","show_progress", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxHtmlHelpFrame_RefreshLists",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_RefreshLists. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_RefreshLists(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_CreateContents(_swigobj,_swigarg0) (_swigobj->CreateContents(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpFrame_CreateContents(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ int _arg1 = (int ) FALSE;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","show_progress", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxHtmlHelpFrame_CreateContents",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_CreateContents. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_CreateContents(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_CreateIndex(_swigobj,_swigarg0) (_swigobj->CreateIndex(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpFrame_CreateIndex(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ int _arg1 = (int ) FALSE;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","show_progress", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxHtmlHelpFrame_CreateIndex",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_CreateIndex. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_CreateIndex(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_CreateSearch(_swigobj) (_swigobj->CreateSearch())
+static PyObject *_wrap_wxHtmlHelpFrame_CreateSearch(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpFrame_CreateSearch",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_CreateSearch. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_CreateSearch(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_UseConfig(_swigobj,_swigarg0,_swigarg1) (_swigobj->UseConfig(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlHelpFrame_UseConfig(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ wxConfigBase * _arg1;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","config","rootpath", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxHtmlHelpFrame_UseConfig",_kwnames,&_argo0,&_argo1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_UseConfig. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxConfigBase_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxHtmlHelpFrame_UseConfig. Expected _wxConfigBase_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));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_UseConfig(_arg0,_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_ReadCustomization(_swigobj,_swigarg0,_swigarg1) (_swigobj->ReadCustomization(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlHelpFrame_ReadCustomization(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ wxConfigBase * _arg1;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","cfg","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxHtmlHelpFrame_ReadCustomization",_kwnames,&_argo0,&_argo1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_ReadCustomization. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxConfigBase_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxHtmlHelpFrame_ReadCustomization. Expected _wxConfigBase_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));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_ReadCustomization(_arg0,_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpFrame_WriteCustomization(_swigobj,_swigarg0,_swigarg1) (_swigobj->WriteCustomization(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlHelpFrame_WriteCustomization(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _arg0;
+ wxConfigBase * _arg1;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","cfg","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxHtmlHelpFrame_WriteCustomization",_kwnames,&_argo0,&_argo1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpFrame_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpFrame_WriteCustomization. Expected _wxHtmlHelpFrame_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxConfigBase_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxHtmlHelpFrame_WriteCustomization. Expected _wxConfigBase_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));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpFrame_WriteCustomization(_arg0,_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+static void *SwigwxHtmlHelpControllerTowxEvtHandler(void *ptr) {
+ wxHtmlHelpController *src;
+ wxEvtHandler *dest;
+ src = (wxHtmlHelpController *) ptr;
+ dest = (wxEvtHandler *) src;
+ return (void *) dest;
+}
+
+#define new_wxHtmlHelpController() (new wxHtmlHelpController())
+static PyObject *_wrap_new_wxHtmlHelpController(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxHtmlHelpController",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlHelpController *)new_wxHtmlHelpController();
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlHelpController_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define delete_wxHtmlHelpController(_swigobj) (delete _swigobj)
+static PyObject *_wrap_delete_wxHtmlHelpController(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxHtmlHelpController",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxHtmlHelpController. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ delete_wxHtmlHelpController(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_SetTitleFormat(_swigobj,_swigarg0) (_swigobj->SetTitleFormat(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpController_SetTitleFormat(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","format", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpController_SetTitleFormat",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_SetTitleFormat. Expected _wxHtmlHelpController_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;
+ wxHtmlHelpController_SetTitleFormat(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_SetTempDir(_swigobj,_swigarg0) (_swigobj->SetTempDir(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpController_SetTempDir(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpController_SetTempDir",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_SetTempDir. Expected _wxHtmlHelpController_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;
+ wxHtmlHelpController_SetTempDir(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_AddBook(_swigobj,_swigarg0,_swigarg1) (_swigobj->AddBook(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlHelpController_AddBook(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlHelpController * _arg0;
+ wxString * _arg1;
+ int _arg2 = (int ) FALSE;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","book","show_wait_msg", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxHtmlHelpController_AddBook",_kwnames,&_argo0,&_obj1,&_arg2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_AddBook. Expected _wxHtmlHelpController_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 )wxHtmlHelpController_AddBook(_arg0,*_arg1,_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_Display(_swigobj,_swigarg0) (_swigobj->Display(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpController_Display(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","x", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpController_Display",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_Display. Expected _wxHtmlHelpController_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;
+ wxHtmlHelpController_Display(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_DisplayID(_swigobj,_swigarg0) (_swigobj->Display(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpController_DisplayID(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ int _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","id", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxHtmlHelpController_DisplayID",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_DisplayID. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpController_DisplayID(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_DisplayContents(_swigobj) (_swigobj->DisplayContents())
+static PyObject *_wrap_wxHtmlHelpController_DisplayContents(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpController_DisplayContents",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_DisplayContents. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpController_DisplayContents(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_DisplayIndex(_swigobj) (_swigobj->DisplayIndex())
+static PyObject *_wrap_wxHtmlHelpController_DisplayIndex(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpController_DisplayIndex",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_DisplayIndex. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpController_DisplayIndex(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_KeywordSearch(_swigobj,_swigarg0) (_swigobj->KeywordSearch(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpController_KeywordSearch(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxHtmlHelpController * _arg0;
+ wxString * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","keyword", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxHtmlHelpController_KeywordSearch",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_KeywordSearch. Expected _wxHtmlHelpController_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 )wxHtmlHelpController_KeywordSearch(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+{
+ if (_obj1)
+ delete _arg1;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_UseConfig(_swigobj,_swigarg0,_swigarg1) (_swigobj->UseConfig(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlHelpController_UseConfig(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ wxConfigBase * _arg1;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","config","rootpath", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxHtmlHelpController_UseConfig",_kwnames,&_argo0,&_argo1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_UseConfig. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxConfigBase_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxHtmlHelpController_UseConfig. Expected _wxConfigBase_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));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpController_UseConfig(_arg0,_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_ReadCustomization(_swigobj,_swigarg0,_swigarg1) (_swigobj->ReadCustomization(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlHelpController_ReadCustomization(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ wxConfigBase * _arg1;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","cfg","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxHtmlHelpController_ReadCustomization",_kwnames,&_argo0,&_argo1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_ReadCustomization. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxConfigBase_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxHtmlHelpController_ReadCustomization. Expected _wxConfigBase_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));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpController_ReadCustomization(_arg0,_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_WriteCustomization(_swigobj,_swigarg0,_swigarg1) (_swigobj->WriteCustomization(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxHtmlHelpController_WriteCustomization(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ wxConfigBase * _arg1;
+ wxString * _arg2 = (wxString *) &wxEmptyString;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","cfg","path", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxHtmlHelpController_WriteCustomization",_kwnames,&_argo0,&_argo1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_WriteCustomization. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxConfigBase_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxHtmlHelpController_WriteCustomization. Expected _wxConfigBase_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));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpController_WriteCustomization(_arg0,_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_GetFrame(_swigobj) (_swigobj->GetFrame())
+static PyObject *_wrap_wxHtmlHelpController_GetFrame(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpFrame * _result;
+ wxHtmlHelpController * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxHtmlHelpController_GetFrame",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_GetFrame. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxHtmlHelpFrame *)wxHtmlHelpController_GetFrame(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxHtmlHelpFrame_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxHtmlHelpController_CreateHelpWindow(_swigobj,_swigarg0) (_swigobj->CreateHelpWindow(_swigarg0))
+static PyObject *_wrap_wxHtmlHelpController_CreateHelpWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxHtmlHelpController * _arg0;
+ int _arg1 = (int ) FALSE;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","show_progress", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxHtmlHelpController_CreateHelpWindow",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxHtmlHelpController_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxHtmlHelpController_CreateHelpWindow. Expected _wxHtmlHelpController_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxHtmlHelpController_CreateHelpWindow(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static PyMethodDef htmlhelpcMethods[] = {
+ { "wxHtmlHelpController_CreateHelpWindow", (PyCFunction) _wrap_wxHtmlHelpController_CreateHelpWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_GetFrame", (PyCFunction) _wrap_wxHtmlHelpController_GetFrame, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_WriteCustomization", (PyCFunction) _wrap_wxHtmlHelpController_WriteCustomization, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_ReadCustomization", (PyCFunction) _wrap_wxHtmlHelpController_ReadCustomization, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_UseConfig", (PyCFunction) _wrap_wxHtmlHelpController_UseConfig, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_KeywordSearch", (PyCFunction) _wrap_wxHtmlHelpController_KeywordSearch, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_DisplayIndex", (PyCFunction) _wrap_wxHtmlHelpController_DisplayIndex, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_DisplayContents", (PyCFunction) _wrap_wxHtmlHelpController_DisplayContents, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_DisplayID", (PyCFunction) _wrap_wxHtmlHelpController_DisplayID, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_Display", (PyCFunction) _wrap_wxHtmlHelpController_Display, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_AddBook", (PyCFunction) _wrap_wxHtmlHelpController_AddBook, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_SetTempDir", (PyCFunction) _wrap_wxHtmlHelpController_SetTempDir, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpController_SetTitleFormat", (PyCFunction) _wrap_wxHtmlHelpController_SetTitleFormat, METH_VARARGS | METH_KEYWORDS },
+ { "delete_wxHtmlHelpController", (PyCFunction) _wrap_delete_wxHtmlHelpController, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxHtmlHelpController", (PyCFunction) _wrap_new_wxHtmlHelpController, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_WriteCustomization", (PyCFunction) _wrap_wxHtmlHelpFrame_WriteCustomization, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_ReadCustomization", (PyCFunction) _wrap_wxHtmlHelpFrame_ReadCustomization, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_UseConfig", (PyCFunction) _wrap_wxHtmlHelpFrame_UseConfig, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_CreateSearch", (PyCFunction) _wrap_wxHtmlHelpFrame_CreateSearch, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_CreateIndex", (PyCFunction) _wrap_wxHtmlHelpFrame_CreateIndex, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_CreateContents", (PyCFunction) _wrap_wxHtmlHelpFrame_CreateContents, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_RefreshLists", (PyCFunction) _wrap_wxHtmlHelpFrame_RefreshLists, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_KeywordSearch", (PyCFunction) _wrap_wxHtmlHelpFrame_KeywordSearch, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_DisplayIndex", (PyCFunction) _wrap_wxHtmlHelpFrame_DisplayIndex, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_DisplayContents", (PyCFunction) _wrap_wxHtmlHelpFrame_DisplayContents, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_DisplayID", (PyCFunction) _wrap_wxHtmlHelpFrame_DisplayID, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_Display", (PyCFunction) _wrap_wxHtmlHelpFrame_Display, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_SetTitleFormat", (PyCFunction) _wrap_wxHtmlHelpFrame_SetTitleFormat, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrame_GetData", (PyCFunction) _wrap_wxHtmlHelpFrame_GetData, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxHtmlHelpFrame", (PyCFunction) _wrap_new_wxHtmlHelpFrame, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_GetIndexCnt", (PyCFunction) _wrap_wxHtmlHelpData_GetIndexCnt, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_GetIndex", (PyCFunction) _wrap_wxHtmlHelpData_GetIndex, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_GetContentsCnt", (PyCFunction) _wrap_wxHtmlHelpData_GetContentsCnt, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_GetContents", (PyCFunction) _wrap_wxHtmlHelpData_GetContents, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_GetBookRecArray", (PyCFunction) _wrap_wxHtmlHelpData_GetBookRecArray, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_FindPageById", (PyCFunction) _wrap_wxHtmlHelpData_FindPageById, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_FindPageByName", (PyCFunction) _wrap_wxHtmlHelpData_FindPageByName, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_AddBookParam", (PyCFunction) _wrap_wxHtmlHelpData_AddBookParam, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_AddBook", (PyCFunction) _wrap_wxHtmlHelpData_AddBook, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpData_SetTempDir", (PyCFunction) _wrap_wxHtmlHelpData_SetTempDir, METH_VARARGS | METH_KEYWORDS },
+ { "delete_wxHtmlHelpData", (PyCFunction) _wrap_delete_wxHtmlHelpData, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxHtmlHelpData", (PyCFunction) _wrap_new_wxHtmlHelpData, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlSearchStatus_GetContentsItem", (PyCFunction) _wrap_wxHtmlSearchStatus_GetContentsItem, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlSearchStatus_GetName", (PyCFunction) _wrap_wxHtmlSearchStatus_GetName, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlSearchStatus_GetMaxIndex", (PyCFunction) _wrap_wxHtmlSearchStatus_GetMaxIndex, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlSearchStatus_GetCurIndex", (PyCFunction) _wrap_wxHtmlSearchStatus_GetCurIndex, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlSearchStatus_IsActive", (PyCFunction) _wrap_wxHtmlSearchStatus_IsActive, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlSearchStatus_Search", (PyCFunction) _wrap_wxHtmlSearchStatus_Search, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Book_get", (PyCFunction) _wrap_wxHtmlContentsItem_m_Book_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Book_set", (PyCFunction) _wrap_wxHtmlContentsItem_m_Book_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Page_get", (PyCFunction) _wrap_wxHtmlContentsItem_m_Page_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Page_set", (PyCFunction) _wrap_wxHtmlContentsItem_m_Page_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Name_get", (PyCFunction) _wrap_wxHtmlContentsItem_m_Name_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Name_set", (PyCFunction) _wrap_wxHtmlContentsItem_m_Name_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_ID_get", (PyCFunction) _wrap_wxHtmlContentsItem_m_ID_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_ID_set", (PyCFunction) _wrap_wxHtmlContentsItem_m_ID_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Level_get", (PyCFunction) _wrap_wxHtmlContentsItem_m_Level_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlContentsItem_m_Level_set", (PyCFunction) _wrap_wxHtmlContentsItem_m_Level_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlBookRecord_GetContentsEnd", (PyCFunction) _wrap_wxHtmlBookRecord_GetContentsEnd, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlBookRecord_GetContentsStart", (PyCFunction) _wrap_wxHtmlBookRecord_GetContentsStart, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlBookRecord_SetContentsRange", (PyCFunction) _wrap_wxHtmlBookRecord_SetContentsRange, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlBookRecord_GetBasePath", (PyCFunction) _wrap_wxHtmlBookRecord_GetBasePath, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlBookRecord_GetStart", (PyCFunction) _wrap_wxHtmlBookRecord_GetStart, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlBookRecord_GetTitle", (PyCFunction) _wrap_wxHtmlBookRecord_GetTitle, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxHtmlBookRecord", (PyCFunction) _wrap_new_wxHtmlBookRecord, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_titleformat_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_titleformat_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_titleformat_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_titleformat_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_style_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_style_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_style_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_style_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_navig_on_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_navig_on_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_navig_on_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_navig_on_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_sashpos_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_sashpos_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_sashpos_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_sashpos_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_h_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_h_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_h_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_h_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_w_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_w_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_w_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_w_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_y_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_y_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_y_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_y_set, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_x_get", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_x_get, METH_VARARGS | METH_KEYWORDS },
+ { "wxHtmlHelpFrameCfg_x_set", (PyCFunction) _wrap_wxHtmlHelpFrameCfg_x_set, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxHtmlHelpFrameCfg", (PyCFunction) _wrap_new_wxHtmlHelpFrameCfg, METH_VARARGS | METH_KEYWORDS },
+ { NULL, NULL }
+};
+#ifdef __cplusplus
+}
+#endif
+/*
+ * This table is used by the pointer type-checker
+ */
+static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
+ { "_wxAcceleratorTable","_class_wxAcceleratorTable",0},
+ { "_wxEvent","_class_wxEvent",0},
+ { "_class_wxActivateEvent","_wxActivateEvent",0},
+ { "_class_wxHtmlParser","_wxHtmlParser",0},
+ { "_signed_long","_long",0},
+ { "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxJPEGHandler","_wxJPEGHandler",0},
+ { "_wxBMPHandler","_class_wxBMPHandler",0},
+ { "_wxImage","_class_wxImage",0},
+ { "_wxPrintQuality","_int",0},
+ { "_wxPrintQuality","_signed_int",0},
+ { "_wxPrintQuality","_unsigned_int",0},
+ { "_wxPrintQuality","_wxWindowID",0},
+ { "_wxPrintQuality","_uint",0},
+ { "_wxPrintQuality","_EBool",0},
+ { "_wxPrintQuality","_size_t",0},
+ { "_wxFontData","_class_wxFontData",0},
+ { "___wxPyCleanup","_class___wxPyCleanup",0},
+ { "_class_HtmlHistoryItem","_HtmlHistoryItem",0},
+ { "_class_wxRegionIterator","_wxRegionIterator",0},
+ { "_class_wxMenuBar","_wxMenuBar",0},
+ { "_class_wxPyTreeItemData","_wxPyTreeItemData",0},
+ { "_wxHtmlHelpData","_class_wxHtmlHelpData",0},
+ { "_class_wxEvtHandler","_class_wxHtmlHelpController",SwigwxHtmlHelpControllerTowxEvtHandler},
+ { "_class_wxEvtHandler","_wxHtmlHelpController",SwigwxHtmlHelpControllerTowxEvtHandler},
+ { "_class_wxEvtHandler","_class_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxEvtHandler},
+ { "_class_wxEvtHandler","_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxEvtHandler},
+ { "_class_wxEvtHandler","_wxEvtHandler",0},
+ { "_wxPaintEvent","_class_wxPaintEvent",0},
+ { "_wxGIFHandler","_class_wxGIFHandler",0},
+ { "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
+ { "_wxCursor","_class_wxCursor",0},
+ { "_wxNotifyEvent","_class_wxNotifyEvent",0},
+ { "_wxImageHandler","_class_wxImageHandler",0},
+ { "_wxHtmlWidgetCell","_class_wxHtmlWidgetCell",0},
+ { "_class_wxTreeCtrl","_wxTreeCtrl",0},
+ { "_wxMask","_class_wxMask",0},
+ { "_wxToolTip","_class_wxToolTip",0},
+ { "_wxGrid","_class_wxGrid",0},
+ { "_wxPNGHandler","_class_wxPNGHandler",0},
+ { "_class_wxColourData","_wxColourData",0},
+ { "_class_wxPageSetupDialogData","_wxPageSetupDialogData",0},
+ { "_wxPrinter","_class_wxPrinter",0},
+ { "_class_wxHtmlHelpController","_wxHtmlHelpController",0},
+ { "_wxPen","_class_wxPen",0},
+ { "_wxUpdateUIEvent","_class_wxUpdateUIEvent",0},
+ { "_byte","_unsigned_char",0},
+ { "_wxStaticBox","_class_wxStaticBox",0},
+ { "_wxChoice","_class_wxChoice",0},
+ { "_wxSlider","_class_wxSlider",0},
+ { "_wxNotebookEvent","_class_wxNotebookEvent",0},
+ { "_wxPyPrintout","_class_wxPyPrintout",0},
+ { "_long","_wxDash",0},
+ { "_long","_unsigned_long",0},
+ { "_long","_signed_long",0},
+ { "_wxImageList","_class_wxImageList",0},
+ { "_wxDropFilesEvent","_class_wxDropFilesEvent",0},
+ { "_wxBitmapButton","_class_wxBitmapButton",0},
+ { "_wxSashWindow","_class_wxSashWindow",0},
+ { "_class_wxPrintDialogData","_wxPrintDialogData",0},
+ { "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
+ { "_class_wxGauge","_wxGauge",0},
+ { "_class_wxSashEvent","_wxSashEvent",0},
+ { "_wxDC","_class_wxDC",0},
+ { "_wxListEvent","_class_wxListEvent",0},
+ { "_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0},
+ { "_wxProgressDialog","_class_wxProgressDialog",0},
+ { "_class_wxBMPHandler","_wxBMPHandler",0},
+ { "_wxPrintPreview","_class_wxPrintPreview",0},
+ { "_wxSpinEvent","_class_wxSpinEvent",0},
+ { "_wxSashLayoutWindow","_class_wxSashLayoutWindow",0},
+ { "_size_t","_wxPrintQuality",0},
+ { "_size_t","_unsigned_int",0},
+ { "_size_t","_int",0},
+ { "_size_t","_wxWindowID",0},
+ { "_size_t","_uint",0},
+ { "_class_wxRealPoint","_wxRealPoint",0},
+ { "_class_wxMenuItem","_wxMenuItem",0},
+ { "_class_wxPaintEvent","_wxPaintEvent",0},
+ { "_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0},
+ { "_class_wxStatusBar","_wxStatusBar",0},
+ { "_class_wxGIFHandler","_wxGIFHandler",0},
+ { "_class_wxPostScriptDC","_wxPostScriptDC",0},
+ { "_wxPanel","_class_wxPanel",0},
+ { "_wxInitDialogEvent","_class_wxInitDialogEvent",0},
+ { "_wxCheckBox","_class_wxCheckBox",0},
+ { "_wxPyEvent","_class_wxPyEvent",0},
+ { "_wxTextCtrl","_class_wxTextCtrl",0},
+ { "_class_wxMask","_wxMask",0},
+ { "_class_wxToolTip","_wxToolTip",0},
+ { "_class_wxKeyEvent","_wxKeyEvent",0},
+ { "_class_wxGrid","_wxGrid",0},
+ { "_class_wxPNGHandler","_wxPNGHandler",0},
+ { "_wxColour","_class_wxColour",0},
+ { "_class_wxDialog","_wxDialog",0},
+ { "_wxPageSetupDialog","_class_wxPageSetupDialog",0},
+ { "_class_wxPrinter","_wxPrinter",0},
+ { "_wxIdleEvent","_class_wxIdleEvent",0},
+ { "_class_wxUpdateUIEvent","_wxUpdateUIEvent",0},
+ { "_wxToolBar","_class_wxToolBar",0},
+ { "_wxStaticLine","_class_wxStaticLine",0},
+ { "_class_wxLayoutAlgorithm","_wxLayoutAlgorithm",0},
+ { "_wxBrush","_class_wxBrush",0},
+ { "_wxMiniFrame","_class_wxMiniFrame",0},
+ { "_class_wxNotebookEvent","_wxNotebookEvent",0},
+ { "_class_wxPyPrintout","_wxPyPrintout",0},
+ { "_class_wxSashWindow","_wxSashWindow",0},
+ { "_wxShowEvent","_class_wxShowEvent",0},
+ { "_uint","_wxPrintQuality",0},
+ { "_uint","_size_t",0},
+ { "_uint","_unsigned_int",0},
+ { "_uint","_int",0},
+ { "_uint","_wxWindowID",0},
+ { "_class_wxEvent","_wxEvent",0},
+ { "_wxCheckListBox","_class_wxCheckListBox",0},
+ { "_wxSplitterEvent","_class_wxSplitterEvent",0},
+ { "_wxGridEvent","_class_wxGridEvent",0},
+ { "_wxRect","_class_wxRect",0},
+ { "_wxCommandEvent","_class_wxCommandEvent",0},
+ { "_wxSizeEvent","_class_wxSizeEvent",0},
+ { "_class_wxImage","_wxImage",0},
+ { "_wxPoint","_class_wxPoint",0},
+ { "_class_wxSashLayoutWindow","_wxSashLayoutWindow",0},
+ { "_class_wxButton","_wxButton",0},
+ { "_wxRadioBox","_class_wxRadioBox",0},
+ { "_class_wxFontData","_wxFontData",0},
+ { "_class___wxPyCleanup","___wxPyCleanup",0},
+ { "_wxHtmlCell","_class_wxHtmlCell",0},
+ { "_wxBitmap","_class_wxBitmap",0},
+ { "_wxPrintDialog","_class_wxPrintDialog",0},
+ { "_wxPyTimer","_class_wxPyTimer",0},
+ { "_wxWindowDC","_class_wxWindowDC",0},
+ { "_wxScrollBar","_class_wxScrollBar",0},
+ { "_wxSpinButton","_class_wxSpinButton",0},
+ { "_wxToolBarTool","_class_wxToolBarTool",0},
+ { "_wxColourDialog","_class_wxColourDialog",0},
+ { "_wxPrintData","_class_wxPrintData",0},
+ { "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
+ { "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_wxMessageDialog","_class_wxMessageDialog",0},
+ { "_class_wxHtmlWidgetCell","_wxHtmlWidgetCell",0},
+ { "_wxHtmlBookRecord","_class_wxHtmlBookRecord",0},
+ { "_class_wxPyEvent","_wxPyEvent",0},
+ { "_wxTextEntryDialog","_class_wxTextEntryDialog",0},
+ { "_wxConfig","_class_wxConfig",0},
+ { "_class_wxIconizeEvent","_wxIconizeEvent",0},
+ { "_class_wxStaticBitmap","_wxStaticBitmap",0},
+ { "_wxMDIChildFrame","_class_wxMDIChildFrame",0},
+ { "_wxListItem","_class_wxListItem",0},
+ { "_class_wxToolBar","_wxToolBar",0},
+ { "_class_wxStaticLine","_wxStaticLine",0},
+ { "_wxScrollEvent","_class_wxScrollEvent",0},
+ { "_wxCalculateLayoutEvent","_class_wxCalculateLayoutEvent",0},
+ { "_wxPyHtmlTagHandler","_class_wxPyHtmlTagHandler",0},
+ { "_EBool","_wxPrintQuality",0},
+ { "_EBool","_signed_int",0},
+ { "_EBool","_int",0},
+ { "_EBool","_wxWindowID",0},
+ { "_class_wxRegion","_wxRegion",0},
+ { "_class_wxDropFilesEvent","_wxDropFilesEvent",0},
+ { "_class_wxPreviewFrame","_wxPreviewFrame",0},
+ { "_wxHtmlContainerCell","_class_wxHtmlContainerCell",0},
+ { "_wxStaticText","_class_wxStaticText",0},
+ { "_wxFont","_class_wxFont",0},
+ { "_wxCloseEvent","_class_wxCloseEvent",0},
+ { "_class_wxSplitterEvent","_wxSplitterEvent",0},
+ { "_wxNotebook","_class_wxNotebook",0},
+ { "_unsigned_long","_wxDash",0},
+ { "_unsigned_long","_long",0},
+ { "_class_wxRect","_wxRect",0},
+ { "_class_wxDC","_wxDC",0},
+ { "_wxScrollWinEvent","_class_wxScrollWinEvent",0},
+ { "_class_wxProgressDialog","_wxProgressDialog",0},
+ { "_wxPyApp","_class_wxPyApp",0},
+ { "_wxHtmlWinParser","_class_wxHtmlWinParser",0},
+ { "_wxHtmlSearchStatus","_class_wxHtmlSearchStatus",0},
+ { "_wxMDIParentFrame","_class_wxMDIParentFrame",0},
+ { "_class_wxTreeEvent","_wxTreeEvent",0},
+ { "_class_wxDirDialog","_wxDirDialog",0},
+ { "_class_wxPyTimer","_wxPyTimer",0},
+ { "_wxFocusEvent","_class_wxFocusEvent",0},
+ { "_wxMaximizeEvent","_class_wxMaximizeEvent",0},
+ { "_class_wxSpinButton","_wxSpinButton",0},
+ { "_wxAcceleratorEntry","_class_wxAcceleratorEntry",0},
+ { "_class_wxPanel","_wxPanel",0},
+ { "_class_wxCheckBox","_wxCheckBox",0},
+ { "_wxComboBox","_class_wxComboBox",0},
+ { "_wxRadioButton","_class_wxRadioButton",0},
+ { "_class_wxMessageDialog","_wxMessageDialog",0},
+ { "_wxHtmlTag","_class_wxHtmlTag",0},
+ { "_signed_int","_wxPrintQuality",0},
+ { "_signed_int","_EBool",0},
+ { "_signed_int","_wxWindowID",0},
+ { "_signed_int","_int",0},
+ { "_class_wxTextCtrl","_wxTextCtrl",0},
+ { "_wxLayoutConstraints","_class_wxLayoutConstraints",0},
+ { "_wxMenu","_class_wxMenu",0},
+ { "_class_wxMoveEvent","_wxMoveEvent",0},
+ { "_wxListBox","_class_wxListBox",0},
+ { "_wxScreenDC","_class_wxScreenDC",0},
+ { "_class_wxMDIChildFrame","_wxMDIChildFrame",0},
+ { "_class_wxPyHtmlWindow","_wxPyHtmlWindow",0},
+ { "_wxHtmlHelpFrameCfg","_class_wxHtmlHelpFrameCfg",0},
+ { "_wxHtmlHelpController","_class_wxHtmlHelpController",0},
+ { "_WXTYPE","_short",0},
+ { "_WXTYPE","_signed_short",0},
+ { "_WXTYPE","_unsigned_short",0},
+ { "_wxFileDialog","_class_wxFileDialog",0},
+ { "_class_wxMDIClientWindow","_wxMDIClientWindow",0},
+ { "_class_wxBrush","_wxBrush",0},
+ { "_class_wxPyHtmlTagHandler","_wxPyHtmlTagHandler",0},
+ { "_unsigned_short","_WXTYPE",0},
+ { "_unsigned_short","_short",0},
+ { "_class_wxWindow","_class_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxWindow},
+ { "_class_wxWindow","_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxWindow},
+ { "_class_wxWindow","_wxWindow",0},
+ { "_wxSplitterWindow","_class_wxSplitterWindow",0},
+ { "_class_wxStaticText","_wxStaticText",0},
+ { "_wxPrintDialogData","_class_wxPrintDialogData",0},
+ { "_class_wxFont","_wxFont",0},
+ { "_class_wxCloseEvent","_wxCloseEvent",0},
+ { "_wxSashEvent","_class_wxSashEvent",0},
+ { "_class_wxMenuEvent","_wxMenuEvent",0},
+ { "_wxClientDC","_class_wxClientDC",0},
+ { "_wxMouseEvent","_class_wxMouseEvent",0},
+ { "_wxListCtrl","_class_wxListCtrl",0},
+ { "_wxSingleChoiceDialog","_class_wxSingleChoiceDialog",0},
+ { "_class_wxPoint","_wxPoint",0},
+ { "_wxRealPoint","_class_wxRealPoint",0},
+ { "_class_wxRadioBox","_wxRadioBox",0},
+ { "_wxGridCell","_class_wxGridCell",0},
+ { "_class_wxHtmlWinParser","_wxHtmlWinParser",0},
+ { "_class_wxHtmlCell","_wxHtmlCell",0},
+ { "_class_wxHtmlSearchStatus","_wxHtmlSearchStatus",0},
+ { "_signed_short","_WXTYPE",0},
+ { "_signed_short","_short",0},
+ { "_wxMemoryDC","_class_wxMemoryDC",0},
+ { "_class_wxPrintDialog","_wxPrintDialog",0},
+ { "_class_wxHtmlHelpData","_wxHtmlHelpData",0},
+ { "_wxPaintDC","_class_wxPaintDC",0},
+ { "_class_wxWindowDC","_wxWindowDC",0},
+ { "_class_wxFocusEvent","_wxFocusEvent",0},
+ { "_class_wxMaximizeEvent","_wxMaximizeEvent",0},
+ { "_wxStatusBar","_class_wxStatusBar",0},
+ { "_class_wxToolBarTool","_wxToolBarTool",0},
+ { "_class_wxAcceleratorEntry","_wxAcceleratorEntry",0},
+ { "_class_wxCursor","_wxCursor",0},
+ { "_wxPostScriptDC","_class_wxPostScriptDC",0},
+ { "_class_wxImageHandler","_wxImageHandler",0},
+ { "_class_wxHtmlTag","_wxHtmlTag",0},
+ { "_class_wxHtmlBookRecord","_wxHtmlBookRecord",0},
+ { "_wxScrolledWindow","_class_wxScrolledWindow",0},
+ { "_wxTreeItemId","_class_wxTreeItemId",0},
+ { "_unsigned_char","_byte",0},
+ { "_class_wxMenu","_wxMenu",0},
+ { "_wxControl","_class_wxControl",0},
+ { "_class_wxListBox","_wxListBox",0},
+ { "_unsigned_int","_wxPrintQuality",0},
+ { "_unsigned_int","_size_t",0},
+ { "_unsigned_int","_uint",0},
+ { "_unsigned_int","_wxWindowID",0},
+ { "_unsigned_int","_int",0},
+ { "_wxIcon","_class_wxIcon",0},
+ { "_wxDialog","_class_wxDialog",0},
+ { "_class_wxListItem","_wxListItem",0},
+ { "_class_wxHtmlHelpFrameCfg","_wxHtmlHelpFrameCfg",0},
+ { "_class_wxPen","_wxPen",0},
+ { "_class_wxFileDialog","_wxFileDialog",0},
+ { "_wxQueryLayoutInfoEvent","_class_wxQueryLayoutInfoEvent",0},
+ { "_short","_WXTYPE",0},
+ { "_short","_unsigned_short",0},
+ { "_short","_signed_short",0},
+ { "_class_wxStaticBox","_wxStaticBox",0},
+ { "_wxLayoutAlgorithm","_class_wxLayoutAlgorithm",0},
+ { "_class_wxScrollEvent","_wxScrollEvent",0},
+ { "_wxJoystickEvent","_class_wxJoystickEvent",0},
+ { "_class_wxChoice","_wxChoice",0},
+ { "_class_wxSlider","_wxSlider",0},
+ { "_class_wxCalculateLayoutEvent","_wxCalculateLayoutEvent",0},
+ { "_wxHtmlHelpFrame","_class_wxHtmlHelpFrame",0},
+ { "_class_wxImageList","_wxImageList",0},
+ { "_class_wxBitmapButton","_wxBitmapButton",0},
+ { "_class_wxHtmlContainerCell","_wxHtmlContainerCell",0},
+ { "_wxFrame","_class_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxFrame},
+ { "_wxFrame","_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxFrame},
+ { "_wxFrame","_class_wxFrame",0},
+ { "_class_wxNotebook","_wxNotebook",0},
+ { "_wxJPEGHandler","_class_wxJPEGHandler",0},
+ { "_wxWindowID","_wxPrintQuality",0},
+ { "_wxWindowID","_size_t",0},
+ { "_wxWindowID","_EBool",0},
+ { "_wxWindowID","_uint",0},
+ { "_wxWindowID","_int",0},
+ { "_wxWindowID","_signed_int",0},
+ { "_wxWindowID","_unsigned_int",0},
+ { "_class_wxScrollWinEvent","_wxScrollWinEvent",0},
+ { "_int","_wxPrintQuality",0},
+ { "_int","_size_t",0},
+ { "_int","_EBool",0},
+ { "_int","_uint",0},
+ { "_int","_wxWindowID",0},
+ { "_int","_unsigned_int",0},
+ { "_int","_signed_int",0},
+ { "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_class_wxListEvent","_wxListEvent",0},
+ { "_class_wxPrintPreview","_wxPrintPreview",0},
+ { "_class_wxSpinEvent","_wxSpinEvent",0},
+ { "_wxPyHtmlWinTagHandler","_class_wxPyHtmlWinTagHandler",0},
+ { "_wxButton","_class_wxButton",0},
+ { "_class_wxPyApp","_wxPyApp",0},
+ { "_wxSize","_class_wxSize",0},
+ { "_wxRegionIterator","_class_wxRegionIterator",0},
+ { "_class_wxMDIParentFrame","_wxMDIParentFrame",0},
+ { "_wxPyTreeItemData","_class_wxPyTreeItemData",0},
+ { "_class_wxPaintDC","_wxPaintDC",0},
+ { "_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0},
+ { "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
+ { "_class_wxComboBox","_wxComboBox",0},
+ { "_class_wxRadioButton","_wxRadioButton",0},
+ { "_class_wxTreeItemId","_wxTreeItemId",0},
+ { "_wxTreeCtrl","_class_wxTreeCtrl",0},
+ { "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
+ { "_wxIconizeEvent","_class_wxIconizeEvent",0},
+ { "_class_wxControl","_wxControl",0},
+ { "_wxStaticBitmap","_class_wxStaticBitmap",0},
+ { "_class_wxIcon","_wxIcon",0},
+ { "_class_wxColour","_wxColour",0},
+ { "_class_wxScreenDC","_wxScreenDC",0},
+ { "_class_wxPageSetupDialog","_wxPageSetupDialog",0},
+ { "_wxPalette","_class_wxPalette",0},
+ { "_class_wxIdleEvent","_wxIdleEvent",0},
+ { "_wxEraseEvent","_class_wxEraseEvent",0},
+ { "_class_wxJoystickEvent","_wxJoystickEvent",0},
+ { "_class_wxMiniFrame","_wxMiniFrame",0},
+ { "_wxFontDialog","_class_wxFontDialog",0},
+ { "_class_wxHtmlHelpFrame","_wxHtmlHelpFrame",0},
+ { "_wxRegion","_class_wxRegion",0},
+ { "_class_wxSplitterWindow","_wxSplitterWindow",0},
+ { "_wxPreviewFrame","_class_wxPreviewFrame",0},
+ { "_class_wxShowEvent","_wxShowEvent",0},
+ { "_wxActivateEvent","_class_wxActivateEvent",0},
+ { "_wxGauge","_class_wxGauge",0},
+ { "_class_wxCheckListBox","_wxCheckListBox",0},
+ { "_wxHtmlParser","_class_wxHtmlParser",0},
+ { "_class_wxGridEvent","_wxGridEvent",0},
+ { "_class_wxCommandEvent","_wxCommandEvent",0},
+ { "_class_wxClientDC","_wxClientDC",0},
+ { "_class_wxSizeEvent","_wxSizeEvent",0},
+ { "_class_wxListCtrl","_wxListCtrl",0},
+ { "_class_wxPyHtmlWinTagHandler","_wxPyHtmlWinTagHandler",0},
+ { "_class_wxGridCell","_wxGridCell",0},
+ { "_HtmlHistoryItem","_class_HtmlHistoryItem",0},
+ { "_class_wxSize","_wxSize",0},
+ { "_class_wxBitmap","_wxBitmap",0},
+ { "_class_wxMemoryDC","_wxMemoryDC",0},
+ { "_wxMenuBar","_class_wxMenuBar",0},
+ { "_wxTreeEvent","_class_wxTreeEvent",0},
+ { "_wxDirDialog","_class_wxDirDialog",0},
+ { "_wxEvtHandler","_class_wxHtmlHelpController",SwigwxHtmlHelpControllerTowxEvtHandler},
+ { "_wxEvtHandler","_wxHtmlHelpController",SwigwxHtmlHelpControllerTowxEvtHandler},
+ { "_wxEvtHandler","_class_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxEvtHandler},
+ { "_wxEvtHandler","_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxEvtHandler},
+ { "_wxEvtHandler","_class_wxEvtHandler",0},
+ { "_wxMenuItem","_class_wxMenuItem",0},
+ { "_class_wxScrollBar","_wxScrollBar",0},
+ { "_class_wxColourDialog","_wxColourDialog",0},
+ { "_class_wxPrintData","_wxPrintData",0},
+ { "_wxDash","_unsigned_long",0},
+ { "_wxDash","_long",0},
+ { "_class_wxScrolledWindow","_wxScrolledWindow",0},
+ { "_class_wxTextEntryDialog","_wxTextEntryDialog",0},
+ { "_class_wxConfig","_wxConfig",0},
+ { "_wxKeyEvent","_class_wxKeyEvent",0},
+ { "_wxMoveEvent","_class_wxMoveEvent",0},
+ { "_wxColourData","_class_wxColourData",0},
+ { "_wxPageSetupDialogData","_class_wxPageSetupDialogData",0},
+ { "_wxPyHtmlWindow","_class_wxPyHtmlWindow",0},
+ { "_class_wxPalette","_wxPalette",0},
+ { "_class_wxQueryLayoutInfoEvent","_wxQueryLayoutInfoEvent",0},
+ { "_class_wxEraseEvent","_wxEraseEvent",0},
+ { "_wxMDIClientWindow","_class_wxMDIClientWindow",0},
+ { "_class_wxFontDialog","_wxFontDialog",0},
+ { "_wxWindow","_class_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxWindow},
+ { "_wxWindow","_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxWindow},
+ { "_wxWindow","_class_wxWindow",0},
+ { "_class_wxFrame","_class_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxFrame},
+ { "_class_wxFrame","_wxHtmlHelpFrame",SwigwxHtmlHelpFrameTowxFrame},
+ { "_class_wxFrame","_wxFrame",0},
+{0,0,0}};
+
+static PyObject *SWIG_globals;
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT(void) inithtmlhelpc() {
+ PyObject *m, *d;
+ SWIG_globals = SWIG_newvarlink();
+ m = Py_InitModule("htmlhelpc", htmlhelpcMethods);
+ d = PyModule_GetDict(m);
+ PyDict_SetItemString(d,"wxID_HTML_PANEL", PyInt_FromLong((long) wxID_HTML_PANEL));
+ PyDict_SetItemString(d,"wxID_HTML_BACK", PyInt_FromLong((long) wxID_HTML_BACK));
+ PyDict_SetItemString(d,"wxID_HTML_FORWARD", PyInt_FromLong((long) wxID_HTML_FORWARD));
+ PyDict_SetItemString(d,"wxID_HTML_TREECTRL", PyInt_FromLong((long) wxID_HTML_TREECTRL));
+ PyDict_SetItemString(d,"wxID_HTML_INDEXPAGE", PyInt_FromLong((long) wxID_HTML_INDEXPAGE));
+ PyDict_SetItemString(d,"wxID_HTML_INDEXLIST", PyInt_FromLong((long) wxID_HTML_INDEXLIST));
+ PyDict_SetItemString(d,"wxID_HTML_NOTEBOOK", PyInt_FromLong((long) wxID_HTML_NOTEBOOK));
+ PyDict_SetItemString(d,"wxID_HTML_SEARCHPAGE", PyInt_FromLong((long) wxID_HTML_SEARCHPAGE));
+ PyDict_SetItemString(d,"wxID_HTML_SEARCHTEXT", PyInt_FromLong((long) wxID_HTML_SEARCHTEXT));
+ PyDict_SetItemString(d,"wxID_HTML_SEARCHLIST", PyInt_FromLong((long) wxID_HTML_SEARCHLIST));
+ PyDict_SetItemString(d,"wxID_HTML_SEARCHBUTTON", PyInt_FromLong((long) wxID_HTML_SEARCHBUTTON));
+{
+ int i;
+ for (i = 0; _swig_mapping[i].n1; i++)
+ SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
+}
+}
%{
#include "helpers.h"
#include <wx/html/htmlwin.h>
+#include <wx/html/helpctrl.h>
#include <wx/image.h>
#include <wx/fs_zip.h>
#include <wx/fs_inet.h>
#include <wx/wfstream.h>
-#include "helpsys.h"
%}
//---------------------------------------------------------------------------
%extern wx.i
%extern windows.i
+%extern frames.i
%extern _defs.i
%extern events.i
%extern controls.i
wxID_HTML_SEARCHBUTTON
};
-class wxHtmlHelpController : public wxEvtHandler {
+//---------------------------------------------------------------------------
+
+class wxHtmlHelpFrameCfg
+{
public:
- wxHtmlHelpController();
- ~wxHtmlHelpController();
+ wxHtmlHelpFrameCfg();
+
+ long x, y, w, h;
+ long sashpos;
+ bool navig_on;
+ int style;
+ wxString titleformat;
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxHtmlBookRecord {
+public:
+ wxHtmlBookRecord(const wxString& basepath, const wxString& title,
+ const wxString& start);
+
+ wxString GetTitle();
+ wxString GetStart();
+ wxString GetBasePath();
+
+ void SetContentsRange(int start, int end);
+ int GetContentsStart();
+ int GetContentsEnd();
+};
+
+//---------------------------------------------------------------------------
+
+typedef struct
+{
+ short int m_Level;
+ int m_ID;
+ char* m_Name;
+ char* m_Page;
+ wxHtmlBookRecord *m_Book;
+} wxHtmlContentsItem;
+
+//---------------------------------------------------------------------------
+
+class wxHtmlSearchStatus
+{
+public:
+ //wxHtmlSearchStatus(wxHtmlHelpData* base, const wxString& keyword,
+ // const wxString& book = wxEmptyString);
+ bool Search();
+ bool IsActive();
+ int GetCurIndex();
+ int GetMaxIndex();
+ const wxString& GetName();
+ wxHtmlContentsItem* GetContentsItem();
+};
- // Images:
- enum {
- IMG_Book = 0,
- IMG_Folder,
- IMG_Page
- };
+//---------------------------------------------------------------------------
- void SetTitleFormat(const wxString& format) {m_TitleFormat = format;}
- // Sets format of title of the frame. Must contain exactly one "%s"
- // (for title of displayed HTML page)
+class wxHtmlHelpData {
+public:
+ wxHtmlHelpData();
+ ~wxHtmlHelpData();
void SetTempDir(const wxString& path);
- // Sets directory where temporary files are stored.
- // These temp files are index & contents file in binary (much faster to read)
- // form. These files are NOT deleted on program's exit.
+ bool AddBook(const wxString& book);
+ bool AddBookParam(const wxString& title, const wxString& contfile,
+ const wxString& indexfile=wxEmptyString,
+ const wxString& deftopic=wxEmptyString,
+ const wxString& path=wxEmptyString);
- bool AddBook(const wxString& book, bool show_wait_msg = FALSE);
- // Adds new book. 'book' is location of .htb file (stands for "html book").
- // See documentation for details on its format.
- // Returns success.
- // If show_wait_msg == true then message window with "loading book..." is displayed
+ wxString FindPageByName(const wxString& page);
+ wxString FindPageById(int id);
- void Display(const wxString& x);
- // Displays page x. If not found it will offect the user a choice of searching
- // books.
- // Looking for the page runs in these steps:
- // 1. try to locate file named x (if x is for example "doc/howto.htm")
- // 2. try to open starting page of book x
- // 3. try to find x in contents (if x is for example "How To ...")
- // 4. try to find x in index (if x is for example "How To ...")
- // 5. offer searching and if the user agree, run KeywordSearch
- %name(DisplayID) void Display(const int id);
- // Alternative version that works with numeric ID.
- // (uses extension to MS format, <param name="ID" value=id>, see docs)
+ // **** this one needs fixed...
+ const wxHtmlBookRecArray& GetBookRecArray();
- void DisplayContents();
- // Displays help window and focuses contents.
+ wxHtmlContentsItem* GetContents();
+ int GetContentsCnt();
+ wxHtmlContentsItem* GetIndex();
+ int GetIndexCnt();
+};
- void DisplayIndex();
- // Displays help window and focuses index.
+//---------------------------------------------------------------------------
- bool KeywordSearch(const wxString& keyword);
- // Searches for keyword. Returns TRUE and display page if found, return
- // FALSE otherwise
- // Syntax of keyword is Altavista-like:
- // * words are separated by spaces
- // (but "\"hello world\"" is only one world "hello world")
- // * word may be pretended by + or -
- // (+ : page must contain the word ; - : page can't contain the word)
- // * if there is no + or - before the word, + is default
+class wxHtmlHelpFrame : public wxFrame {
+public:
+ wxHtmlHelpFrame(wxWindow* parent, int wxWindowID,
+ const wxString& title = wxEmptyString,
+ int style = wxHF_DEFAULTSTYLE, wxHtmlHelpData* data = NULL);
+ wxHtmlHelpData* GetData();
+ void SetTitleFormat(const wxString& format);
+ void Display(const wxString& x);
+ %name(DisplayID) void Display(int id);
+ void DisplayContents();
+ void DisplayIndex();
+ bool KeywordSearch(const wxString& keyword);
+ void RefreshLists(int show_progress = FALSE);
+ void CreateContents(int show_progress = FALSE);
+ void CreateIndex(int show_progress = FALSE);
+ void CreateSearch();
void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString);
- // Assigns config object to the controller. This config is then
- // used in subsequent calls to Read/WriteCustomization of both help
- // controller and it's wxHtmlWindow
+ void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
+ void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
+};
+
+//---------------------------------------------------------------------------
+
+class wxHtmlHelpController : public wxEvtHandler {
+public:
+ wxHtmlHelpController();
+ ~wxHtmlHelpController();
+
+ void SetTitleFormat(const wxString& format);
+ void SetTempDir(const wxString& path);
+ bool AddBook(const wxString& book, int show_wait_msg = FALSE);
+ void Display(const wxString& x);
+ %name(DisplayID) void Display(int id);
+ void DisplayContents();
+ void DisplayIndex();
+ bool KeywordSearch(const wxString& keyword);
+ void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString);
void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
- // saves custom settings into cfg config. it will use the path 'path'
- // if given, otherwise it will save info into currently selected path.
- // saved values : things set by SetFonts, SetBorders.
void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
- // ...
+ wxHtmlHelpFrame* GetFrame();
+ void CreateHelpWindow(int show_progress = FALSE);
};
+//---------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#ifdef DO_WE_NEED_TO_KEEP_THIS
class wxHtmlHelpSystem : public wxHtmlHelpController {
public:
wxHtmlHelpSystem() {};
}
};
#endif
-
+#endif
//---------------------------------------------------------------------------
--- /dev/null
+# This file was created automatically by SWIG.
+import htmlhelpc
+
+from misc import *
+
+from misc2 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 *
+
+from image import *
+
+from printfw import *
+class wxHtmlHelpFrameCfgPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def __setattr__(self,name,value):
+ if name == "x" :
+ htmlhelpc.wxHtmlHelpFrameCfg_x_set(self,value)
+ return
+ if name == "y" :
+ htmlhelpc.wxHtmlHelpFrameCfg_y_set(self,value)
+ return
+ if name == "w" :
+ htmlhelpc.wxHtmlHelpFrameCfg_w_set(self,value)
+ return
+ if name == "h" :
+ htmlhelpc.wxHtmlHelpFrameCfg_h_set(self,value)
+ return
+ if name == "sashpos" :
+ htmlhelpc.wxHtmlHelpFrameCfg_sashpos_set(self,value)
+ return
+ if name == "navig_on" :
+ htmlhelpc.wxHtmlHelpFrameCfg_navig_on_set(self,value)
+ return
+ if name == "style" :
+ htmlhelpc.wxHtmlHelpFrameCfg_style_set(self,value)
+ return
+ if name == "titleformat" :
+ htmlhelpc.wxHtmlHelpFrameCfg_titleformat_set(self,value)
+ return
+ self.__dict__[name] = value
+ def __getattr__(self,name):
+ if name == "x" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_x_get(self)
+ if name == "y" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_y_get(self)
+ if name == "w" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_w_get(self)
+ if name == "h" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_h_get(self)
+ if name == "sashpos" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_sashpos_get(self)
+ if name == "navig_on" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_navig_on_get(self)
+ if name == "style" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_style_get(self)
+ if name == "titleformat" :
+ return htmlhelpc.wxHtmlHelpFrameCfg_titleformat_get(self)
+ raise AttributeError,name
+ def __repr__(self):
+ return "<C wxHtmlHelpFrameCfg instance at %s>" % (self.this,)
+class wxHtmlHelpFrameCfg(wxHtmlHelpFrameCfgPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(htmlhelpc.new_wxHtmlHelpFrameCfg,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxHtmlBookRecordPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def GetTitle(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlBookRecord_GetTitle,(self,) + _args, _kwargs)
+ return val
+ def GetStart(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlBookRecord_GetStart,(self,) + _args, _kwargs)
+ return val
+ def GetBasePath(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlBookRecord_GetBasePath,(self,) + _args, _kwargs)
+ return val
+ def SetContentsRange(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlBookRecord_SetContentsRange,(self,) + _args, _kwargs)
+ return val
+ def GetContentsStart(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlBookRecord_GetContentsStart,(self,) + _args, _kwargs)
+ return val
+ def GetContentsEnd(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlBookRecord_GetContentsEnd,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxHtmlBookRecord instance at %s>" % (self.this,)
+class wxHtmlBookRecord(wxHtmlBookRecordPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(htmlhelpc.new_wxHtmlBookRecord,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxHtmlContentsItemPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def __setattr__(self,name,value):
+ if name == "m_Level" :
+ htmlhelpc.wxHtmlContentsItem_m_Level_set(self,value)
+ return
+ if name == "m_ID" :
+ htmlhelpc.wxHtmlContentsItem_m_ID_set(self,value)
+ return
+ if name == "m_Name" :
+ htmlhelpc.wxHtmlContentsItem_m_Name_set(self,value)
+ return
+ if name == "m_Page" :
+ htmlhelpc.wxHtmlContentsItem_m_Page_set(self,value)
+ return
+ if name == "m_Book" :
+ htmlhelpc.wxHtmlContentsItem_m_Book_set(self,value.this)
+ return
+ self.__dict__[name] = value
+ def __getattr__(self,name):
+ if name == "m_Level" :
+ return htmlhelpc.wxHtmlContentsItem_m_Level_get(self)
+ if name == "m_ID" :
+ return htmlhelpc.wxHtmlContentsItem_m_ID_get(self)
+ if name == "m_Name" :
+ return htmlhelpc.wxHtmlContentsItem_m_Name_get(self)
+ if name == "m_Page" :
+ return htmlhelpc.wxHtmlContentsItem_m_Page_get(self)
+ if name == "m_Book" :
+ return wxHtmlBookRecordPtr(htmlhelpc.wxHtmlContentsItem_m_Book_get(self))
+ raise AttributeError,name
+ def __repr__(self):
+ return "<C wxHtmlContentsItem instance at %s>" % (self.this,)
+class wxHtmlContentsItem(wxHtmlContentsItemPtr):
+ def __init__(self,this):
+ self.this = this
+
+
+
+
+class wxHtmlSearchStatusPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def Search(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlSearchStatus_Search,(self,) + _args, _kwargs)
+ return val
+ def IsActive(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlSearchStatus_IsActive,(self,) + _args, _kwargs)
+ return val
+ def GetCurIndex(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlSearchStatus_GetCurIndex,(self,) + _args, _kwargs)
+ return val
+ def GetMaxIndex(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlSearchStatus_GetMaxIndex,(self,) + _args, _kwargs)
+ return val
+ def GetName(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlSearchStatus_GetName,(self,) + _args, _kwargs)
+ return val
+ def GetContentsItem(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlSearchStatus_GetContentsItem,(self,) + _args, _kwargs)
+ if val: val = wxHtmlContentsItemPtr(val)
+ return val
+ def __repr__(self):
+ return "<C wxHtmlSearchStatus instance at %s>" % (self.this,)
+class wxHtmlSearchStatus(wxHtmlSearchStatusPtr):
+ def __init__(self,this):
+ self.this = this
+
+
+
+
+class wxHtmlHelpDataPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def __del__(self,htmlhelpc=htmlhelpc):
+ if self.thisown == 1 :
+ htmlhelpc.delete_wxHtmlHelpData(self)
+ def SetTempDir(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_SetTempDir,(self,) + _args, _kwargs)
+ return val
+ def AddBook(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_AddBook,(self,) + _args, _kwargs)
+ return val
+ def AddBookParam(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_AddBookParam,(self,) + _args, _kwargs)
+ return val
+ def FindPageByName(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_FindPageByName,(self,) + _args, _kwargs)
+ return val
+ def FindPageById(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_FindPageById,(self,) + _args, _kwargs)
+ return val
+ def GetBookRecArray(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_GetBookRecArray,(self,) + _args, _kwargs)
+ return val
+ def GetContents(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_GetContents,(self,) + _args, _kwargs)
+ if val: val = wxHtmlContentsItemPtr(val)
+ return val
+ def GetContentsCnt(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_GetContentsCnt,(self,) + _args, _kwargs)
+ return val
+ def GetIndex(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_GetIndex,(self,) + _args, _kwargs)
+ if val: val = wxHtmlContentsItemPtr(val)
+ return val
+ def GetIndexCnt(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpData_GetIndexCnt,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxHtmlHelpData instance at %s>" % (self.this,)
+class wxHtmlHelpData(wxHtmlHelpDataPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(htmlhelpc.new_wxHtmlHelpData,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxHtmlHelpFramePtr(wxFramePtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def GetData(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_GetData,(self,) + _args, _kwargs)
+ if val: val = wxHtmlHelpDataPtr(val)
+ return val
+ def SetTitleFormat(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_SetTitleFormat,(self,) + _args, _kwargs)
+ return val
+ def Display(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_Display,(self,) + _args, _kwargs)
+ return val
+ def DisplayID(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_DisplayID,(self,) + _args, _kwargs)
+ return val
+ def DisplayContents(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_DisplayContents,(self,) + _args, _kwargs)
+ return val
+ def DisplayIndex(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_DisplayIndex,(self,) + _args, _kwargs)
+ return val
+ def KeywordSearch(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_KeywordSearch,(self,) + _args, _kwargs)
+ return val
+ def RefreshLists(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_RefreshLists,(self,) + _args, _kwargs)
+ return val
+ def CreateContents(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_CreateContents,(self,) + _args, _kwargs)
+ return val
+ def CreateIndex(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_CreateIndex,(self,) + _args, _kwargs)
+ return val
+ def CreateSearch(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_CreateSearch,(self,) + _args, _kwargs)
+ return val
+ def UseConfig(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_UseConfig,(self,) + _args, _kwargs)
+ return val
+ def ReadCustomization(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_ReadCustomization,(self,) + _args, _kwargs)
+ return val
+ def WriteCustomization(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpFrame_WriteCustomization,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxHtmlHelpFrame instance at %s>" % (self.this,)
+class wxHtmlHelpFrame(wxHtmlHelpFramePtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(htmlhelpc.new_wxHtmlHelpFrame,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxHtmlHelpControllerPtr(wxEvtHandlerPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def __del__(self,htmlhelpc=htmlhelpc):
+ if self.thisown == 1 :
+ htmlhelpc.delete_wxHtmlHelpController(self)
+ def SetTitleFormat(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_SetTitleFormat,(self,) + _args, _kwargs)
+ return val
+ def SetTempDir(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_SetTempDir,(self,) + _args, _kwargs)
+ return val
+ def AddBook(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_AddBook,(self,) + _args, _kwargs)
+ return val
+ def Display(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_Display,(self,) + _args, _kwargs)
+ return val
+ def DisplayID(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_DisplayID,(self,) + _args, _kwargs)
+ return val
+ def DisplayContents(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_DisplayContents,(self,) + _args, _kwargs)
+ return val
+ def DisplayIndex(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_DisplayIndex,(self,) + _args, _kwargs)
+ return val
+ def KeywordSearch(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_KeywordSearch,(self,) + _args, _kwargs)
+ return val
+ def UseConfig(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_UseConfig,(self,) + _args, _kwargs)
+ return val
+ def ReadCustomization(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_ReadCustomization,(self,) + _args, _kwargs)
+ return val
+ def WriteCustomization(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_WriteCustomization,(self,) + _args, _kwargs)
+ return val
+ def GetFrame(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_GetFrame,(self,) + _args, _kwargs)
+ if val: val = wxHtmlHelpFramePtr(val)
+ return val
+ def CreateHelpWindow(self, *_args, **_kwargs):
+ val = apply(htmlhelpc.wxHtmlHelpController_CreateHelpWindow,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxHtmlHelpController instance at %s>" % (self.this,)
+class wxHtmlHelpController(wxHtmlHelpControllerPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(htmlhelpc.new_wxHtmlHelpController,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+wxID_HTML_PANEL = htmlhelpc.wxID_HTML_PANEL
+wxID_HTML_BACK = htmlhelpc.wxID_HTML_BACK
+wxID_HTML_FORWARD = htmlhelpc.wxID_HTML_FORWARD
+wxID_HTML_TREECTRL = htmlhelpc.wxID_HTML_TREECTRL
+wxID_HTML_INDEXPAGE = htmlhelpc.wxID_HTML_INDEXPAGE
+wxID_HTML_INDEXLIST = htmlhelpc.wxID_HTML_INDEXLIST
+wxID_HTML_NOTEBOOK = htmlhelpc.wxID_HTML_NOTEBOOK
+wxID_HTML_SEARCHPAGE = htmlhelpc.wxID_HTML_SEARCHPAGE
+wxID_HTML_SEARCHTEXT = htmlhelpc.wxID_HTML_SEARCHTEXT
+wxID_HTML_SEARCHLIST = htmlhelpc.wxID_HTML_SEARCHLIST
+wxID_HTML_SEARCHBUTTON = htmlhelpc.wxID_HTML_SEARCHBUTTON
# Licence: wxWindows license
#----------------------------------------------------------------------------
-# ensure the main extension module is loaded, in case the add-on modules
-# (such as utils,) are used standalone. This hack should go away soon.
+import __version__
+__version__ = __version__.ver
+
+
+# Ensure the main extension module is loaded, in case the add-on modules
+# (such as utils,) are used standalone.
import wxc
+wxc.__version__ = __version__
#----------------------------------------------------------------------------
--- /dev/null
+ver = '2.1.4'
class wxUpdateUIEvent;
class wxWindowDC;
class wxWindow;
+class wxSizer;
+class wxBoxSizer;
+class wxStaticBoxSizer;
class wxPyApp;
class wxPyMenu;
wxALIGN_CENTER,
wxALIGN_CENTRE,
wxALIGN_RIGHT,
+ wxALIGN_BOTTOM,
+ wxALIGN_TOP,
wxLB_NEEDED_SB,
wxLB_ALWAYS_SB,
wxLB_SORT,
wxEVT_COMMAND_LIST_INSERT_ITEM,
wxEVT_COMMAND_LIST_COL_CLICK,
wxEVT_COMMAND_LIST_ITEM_ACTIVATED,
+ wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK,
+ wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK,
+
/* Tab and notebook control event types */
wxEVT_COMMAND_TAB_SEL_CHANGED,
wxEVT_COMMAND_SPLITTER_UNSPLIT,
wxEVT_COMMAND_SPLITTER_DOUBLECLICKED,
+ wxEVT_NAVIGATION_KEY,
+
};
def EVT_LIST_COL_CLICK(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_COL_CLICK, func)
+def EVT_LIST_ITEM_RIGHT_CLICK(win, id, func):
+ win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, func)
+
+def EVT_LIST_ITEM_MIDDLE_CLICK(win, id, func):
+ win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK, func)
+
+
+
#wxSplitterWindow
def EVT_SPLITTER_SASH_POS_CHANGING(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING, func)
wxPyDefaultSize.Set(-1,-1)
# aliases so that C++ documentation applies:
-wxDefaultPosition = wxPyDefaultPosition
-wxDefaultSize = wxPyDefaultSize
-
+wxDefaultPosition = wxPyDefaultPosition
+wxDefaultSize = wxPyDefaultSize
-# This is to cover up a bug in SWIG. We are redefining
-# the shadow class that is generated for wxAcceleratorTable
-# because SWIG incorrectly uses "arg0.this"
-class wxAcceleratorTable(wxAcceleratorTablePtr):
- def __init__(self,arg0) :
- self.this = miscc.new_wxAcceleratorTable(arg0)
- self.thisown = 1
#----------------------------------------------------------------------
# This helper function will take a wxPython object and convert it to
#----------------------------------------------------------------------
-## class wxPyStdOutWindow:
-## def __init__(self, title = "wxPython: stdout/stderr"):
-## self.frame = None
-## self.title = title
+class wxPyOnDemandOutputWindow:
+ def __init__(self, title = "wxPython: stdout/stderr"):
+ self.frame = None
+ self.title = title
+
+ def SetParent(self, parent):
+ self.parent = parent
-## 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):
+ if self.frame != None:
+ self.frame.Destroy()
+ self.frame = None
+ self.text = None
-## def OnCloseWindow(self, event):
-## wxBell()
-## self.frame.Destroy()
-## self.frame = None
-## self.text = None
+ # this provides the file-like behaviour
+ def write(self, str):
+ if not self.frame:
+ self.frame = wxFrame(self.parent, -1, self.title)
+ self.text = wxTextCtrl(self.frame, -1, "",
+ style = 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 close(self):
+ self.frame = None
+ self.text = None
-## def close(self):
-## if self.frame:
-## self.frame.Close(true)
_defRedirect = (wxPlatform == '__WXMSW__')
class wxApp(wxPyApp):
error = 'wxApp.error'
+ outputWindowClass = wxPyOnDemandOutputWindow
def __init__(self, redirect=_defRedirect, filename=None):
wxPyApp.__init__(self)
self.saveStdio = (sys.stdout, sys.stderr)
if redirect:
self.RedirectStdio(filename)
-
# this initializes wxWindows and then calls our OnInit
_wxStart(self.OnInit)
except:
pass
+
+ def SetTopWindow(self, frame):
+ if self.stdioWin:
+ self.stdioWin.SetParent(frame)
+ sys.stdout = self.stdioWin #sys.stderr =
+ wxPyApp.SetTopWindow(self, frame)
+
+ def MainLoop(self):
+ wxPyApp.MainLoop(self)
+ self.RestoreStdio()
+
def RedirectStdio(self, filename):
if filename:
sys.stdout = sys.stderr = open(filename, 'a')
else:
- raise self.error, 'wxPyStdOutWindow not yet implemented.'
- #self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow()
+ self.stdioWin = self.outputWindowClass() # wxPyOnDemandOutputWindow
def RestoreStdio(self):
sys.stdout, sys.stderr = self.saveStdio
self.stdioWin.close()
+
#----------------------------------------------------------------------------
# DO NOT hold any other references to this object. This is how we know when
# to cleanup system resources that wxWin is holding...
SWIGFILES = ['wx.i', 'windows.i', 'windows2.i', 'windows3.i', 'events.i',
'misc.i', 'misc2.i', 'gdi.i', 'mdi.i', 'controls.i',
'controls2.i', 'cmndlgs.i', 'stattool.i', 'frames.i',
- 'image.i', 'printfw.i',
+ 'image.i', 'printfw.i', 'sizers.i',
]
-PYFILES = ['__init__.py']
+PYFILES = ['__init__.py', '__version__.py']
SWIGDEPS = '_defs.i my_typemaps.i'
OTHERDEPS = 'helpers.h'
dist:
cd ..\..
wxPython\distrib\zipit.bat $(VERSION)
+
+
"""
else:
rm -f $(HELPERLIBDIR)/lib$(HELPERLIB)$(SO)
+
#----------------------------------------------------------------------
dist: tgz rpm
+OTHERRULES = OTHERRULES + """
+__version__.py: ../distrib/build.py build.cfg
+ @echo ver = '$(VERSION)' > __version__.py
+
+
+$(GENCODEDIR)/wx.py : _extras.py
+
+"""
wxValidator wxPyDefaultValidator; // Non-const default because of SWIG
%}
+%readonly
+wxValidator wxDefaultValidator;
+%readwrite
+
//----------------------------------------------------------------------
class wxControl : public wxWindow {
}
}
+ void InsertItems(int LCOUNT, wxString* LIST, int pos);
+
wxString GetString(int n);
wxString GetStringSelection();
int Number();
%{
#include "helpers.h"
+#ifdef __WXMSW__
+#include <windows.h>
+#endif
#include <wx/listctrl.h>
#include <wx/treectrl.h>
%}
};
+//---------------------------------------------------------------------------
+
+// class wxNavigationKeyEvent : public wxCommandEvent {
+// public:
+// wxNavigationKeyEvent();
+
+// bool GetDirection();
+// void SetDirection(bool bForward);
+// bool IsWindowChange();
+// void SetWindowChange(bool bIs);
+// wxWindow* GetCurrentFocus();
+// void SetCurrentFocus(wxWindow *win);
+// };
+
+
//---------------------------------------------------------------------------
class wxMoveEvent: public wxEvent {
//---------------------------------------------------------------------------
-class wxPyEvent : public wxCommandEvent {
+
+class wxNotifyEvent : public wxCommandEvent {
public:
- wxPyEvent(wxEventType commandType = wxEVT_NULL, PyObject* userData = Py_None);
- ~wxPyEvent();
+ bool IsAllowed();
+ void Veto();
+};
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+// This one can be derived from in Python and passed through the event
+// system without loosing anything so long as the Python data is saved with
+// SetPyData...
- void SetUserData(PyObject* userData);
- PyObject* GetUserData();
+%{
+class wxPyEvent : public wxEvent {
+ DECLARE_DYNAMIC_CLASS(wxPyEvent)
+public:
+ wxPyEvent(int id=0, PyObject* userData = Py_None)
+ : wxEvent(id) {
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ }
+
+ ~wxPyEvent() {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+
+ void SetPyData(PyObject* userData) {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+
+ PyObject* GetPyData() const {
+ Py_INCREF(m_userData);
+ return m_userData;
+ }
+
+ // This one is so the event object can be Cloned...
+ void CopyObject(wxObject& dest) const {
+ wxEvent::CopyObject(dest);
+ ((wxPyEvent*)&dest)->SetPyData(m_userData);
+ }
+
+private:
+ PyObject* m_userData;
};
+IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxEvent)
+
+%}
+class wxPyEvent : public wxEvent {
+public:
+ wxPyEvent(int id=0, PyObject* userData = Py_None);
+ ~wxPyEvent();
+
+ void SetPyData(PyObject* userData);
+ PyObject* GetPyData();
+};
+
//---------------------------------------------------------------------------
+// Same for this one except it is a wxCommandEvent and so will get passed up the
+// containment heirarchy.
-class wxNotifyEvent : public wxCommandEvent {
+%{
+class wxPyCommandEvent : public wxCommandEvent {
+ DECLARE_DYNAMIC_CLASS(wxPyCommandEvent)
public:
- bool IsAllowed();
- void Veto();
+ wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0, PyObject* userData = Py_None)
+ : wxCommandEvent(commandType, id) {
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ }
+
+ ~wxPyCommandEvent() {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+
+ void SetPyData(PyObject* userData) {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+
+ PyObject* GetPyData() const {
+ Py_INCREF(m_userData);
+ return m_userData;
+ }
+
+ // This one is so the event object can be Cloned...
+ void CopyObject(wxObject& dest) const {
+ wxCommandEvent::CopyObject(dest);
+ ((wxPyCommandEvent*)&dest)->SetPyData(m_userData);
+ }
+
+private:
+ PyObject* m_userData;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxPyCommandEvent, wxCommandEvent)
+
+%}
+
+
+class wxPyCommandEvent : public wxCommandEvent {
+public:
+ wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0, PyObject* userData = Py_None);
+ ~wxPyCommandEvent();
+
+ void SetPyData(PyObject* userData);
+ PyObject* GetPyData();
};
+
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxPyCallback, wxObject);
+
wxPyCallback::wxPyCallback(PyObject* func) {
m_func = func;
Py_INCREF(m_func);
}
+wxPyCallback::wxPyCallback(const wxPyCallback& other) {
+ m_func = other.m_func;
+ Py_INCREF(m_func);
+}
+
wxPyCallback::~wxPyCallback() {
bool doSave = wxPyRestoreThread();
Py_DECREF(m_func);
wxPySaveThread(doSave);
}
-void wxPyCallbackHelper::setSelf(PyObject* self) {
+wxPyCallbackHelper::wxPyCallbackHelper(const wxPyCallbackHelper& other) {
+ m_lastFound = NULL;
+ m_self = other.m_self;
+ if (m_self)
+ Py_INCREF(m_self);
+}
+
+
+void wxPyCallbackHelper::setSelf(PyObject* self, int incref) {
m_self = self;
- Py_INCREF(m_self);
+ if (incref)
+ Py_INCREF(m_self);
}
}
-//----------------------------------------------------------------------
-
-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() {
- bool doSave = wxPyRestoreThread();
- if (m_userData != Py_None) {
- Py_DECREF(m_userData);
- m_userData = Py_None;
- }
- wxPySaveThread(doSave);
-}
-
-
-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;
-}
-
-//----------------------------------------------------------------------
+//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Convert a wxList to a Python List
// included in every file...
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source) {
+byte* byte_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
}
-HELPEREXPORT int* int_LIST_helper(PyObject* source) {
+int* int_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
}
-HELPEREXPORT long* long_LIST_helper(PyObject* source) {
+long* long_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
}
-HELPEREXPORT char** string_LIST_helper(PyObject* source) {
+char** string_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source) {
+wxPoint* wxPoint_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
}
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
+wxBitmap** wxBitmap_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source) {
+wxString* wxString_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
}
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
+wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
if (!PyList_Check(source)) {
PyErr_SetString(PyExc_TypeError, "Expected a list object.");
return NULL;
//----------------------------------------------------------------------
+bool wxSize_helper(PyObject* source, wxSize** obj) {
+
+ // If source is an object instance then it may already be the right type
+ if (PyInstance_Check(source)) {
+ wxSize* ptr;
+ if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxSize_p"))
+ goto error;
+ *obj = ptr;
+ return TRUE;
+ }
+ // otherwise a 2-tuple of integers is expected
+ else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
+ PyObject* o1 = PySequence_GetItem(source, 0);
+ PyObject* o2 = PySequence_GetItem(source, 1);
+ **obj = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
+ return TRUE;
+ }
+
+ error:
+ PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxSize object.");
+ return FALSE;
+}
+
+bool wxPoint_helper(PyObject* source, wxPoint** obj) {
+
+ // If source is an object instance then it may already be the right type
+ if (PyInstance_Check(source)) {
+ wxPoint* ptr;
+ if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxPoint_p"))
+ goto error;
+ *obj = ptr;
+ return TRUE;
+ }
+ // otherwise a 2-tuple of integers is expected
+ else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
+ PyObject* o1 = PySequence_GetItem(source, 0);
+ PyObject* o2 = PySequence_GetItem(source, 1);
+ **obj = wxPoint(PyInt_AsLong(o1), PyInt_AsLong(o2));
+ return TRUE;
+ }
+
+ error:
+ PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxPoint object.");
+ return FALSE;
+}
+
+
+
+bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj) {
+
+ // If source is an object instance then it may already be the right type
+ if (PyInstance_Check(source)) {
+ wxRealPoint* ptr;
+ if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRealPoint_p"))
+ goto error;
+ *obj = ptr;
+ return TRUE;
+ }
+ // otherwise a 2-tuple of floats is expected
+ else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
+ PyObject* o1 = PySequence_GetItem(source, 0);
+ PyObject* o2 = PySequence_GetItem(source, 1);
+ **obj = wxRealPoint(PyFloat_AsDouble(o1), PyFloat_AsDouble(o2));
+ return TRUE;
+ }
+
+ error:
+ PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of floats or a wxRealPoint object.");
+ return FALSE;
+}
+
+
+
+
+bool wxRect_helper(PyObject* source, wxRect** obj) {
+
+ // If source is an object instance then it may already be the right type
+ if (PyInstance_Check(source)) {
+ wxRect* ptr;
+ if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxRect_p"))
+ goto error;
+ *obj = ptr;
+ return TRUE;
+ }
+ // otherwise a 4-tuple of integers is expected
+ else if (PySequence_Check(source) && PyObject_Length(source) == 4) {
+ PyObject* o1 = PySequence_GetItem(source, 0);
+ PyObject* o2 = PySequence_GetItem(source, 1);
+ PyObject* o3 = PySequence_GetItem(source, 2);
+ PyObject* o4 = PySequence_GetItem(source, 3);
+ **obj = wxRect(PyInt_AsLong(o1), PyInt_AsLong(o2),
+ PyInt_AsLong(o3), PyInt_AsLong(o4));
+ return TRUE;
+ }
+
+ error:
+ PyErr_SetString(PyExc_TypeError, "Expected a 4-tuple of integers or a wxRect object.");
+ return FALSE;
+}
+
+
+
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
# define HELPEREXPORT
#endif
+typedef unsigned char byte;
+
//----------------------------------------------------------------------
class wxPyApp: public wxApp
HELPEREXPORT PyObject* wxPy_ConvertList(wxListBase* list, char* className);
//----------------------------------------------------------------------
+// These are helpers used by the typemaps
+
+HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
+HELPEREXPORT int* int_LIST_helper(PyObject* source);
+HELPEREXPORT long* long_LIST_helper(PyObject* source);
+HELPEREXPORT char** string_LIST_helper(PyObject* source);
+HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
+HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
+HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
+HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+
+HELPEREXPORT bool wxSize_helper(PyObject* source, wxSize** obj);
+HELPEREXPORT bool wxPoint_helper(PyObject* source, wxPoint** obj);
+HELPEREXPORT bool wxRealPoint_helper(PyObject* source, wxRealPoint** obj);
+HELPEREXPORT bool wxRect_helper(PyObject* source, wxRect** obj);
+//----------------------------------------------------------------------
#ifndef SWIGCODE
extern "C" void SWIG_MakePtr(char *, void *, char *);
# pragma warning(disable:4800)
#endif
-typedef unsigned char byte;
// Non-const versions to keep SWIG happy.
//----------------------------------------------------------------------
class wxPyCallback : public wxObject {
+ DECLARE_ABSTRACT_CLASS(wxPyCallback);
public:
wxPyCallback(PyObject* func);
+ wxPyCallback(const wxPyCallback& other);
~wxPyCallback();
void EventThunker(wxEvent& event);
//---------------------------------------------------------------------------
-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;
-};
-
-
//
// **** This class should be combined with wxPyCallback defined above.
//
-//---------------------------------------------------------------------------
class HELPEREXPORT wxPyCallbackHelper {
public:
wxPyCallbackHelper();
~wxPyCallbackHelper();
- void setSelf(PyObject* self);
+ wxPyCallbackHelper(const wxPyCallbackHelper& other);
+
+ void setSelf(PyObject* self, int incref=TRUE);
bool findCallback(const wxString& name);
int callCallback(PyObject* argTuple);
// return type, if any as well as any parameter types.
//---------------------------------------------------------------------------
-#define PYPRIVATE \
- void _setSelf(PyObject* self) { \
- m_myInst.setSelf(self); \
- } \
+#define PYPRIVATE \
+ void _setSelf(PyObject* self, int incref=TRUE) { \
+ m_myInst.setSelf(self, incref); \
+ } \
private: wxPyCallbackHelper m_myInst;
//---------------------------------------------------------------------------
bool doSave = wxPyRestoreThread(); \
if (m_myInst.findCallback(#CBNAME)) \
m_myInst.callCallback(Py_BuildValue("(Oiddii)", \
- wxPyConstructObject(a, "wxControlPoint"), \
+ wxPyConstructObject(a, "wxPyControlPoint"), \
(int)b, c, d, e, f)); \
else \
PCLASS::CBNAME(a, b, c, d, e, f); \
bool doSave = wxPyRestoreThread(); \
if (m_myInst.findCallback(#CBNAME)) \
m_myInst.callCallback(Py_BuildValue("(Oddii)", \
- wxPyConstructObject(a, "wxControlPoint"), \
+ wxPyConstructObject(a, "wxPyControlPoint"), \
b, c, d, e)); \
else \
PCLASS::CBNAME(a, b, c, d, e); \
}
//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK___pure(CBNAME) \
+ void CBNAME(); \
+
+
+#define IMP_PYCALLBACK___pure(CLASS, PCLASS, CBNAME) \
+ void CLASS::CBNAME() { \
+ bool doSave = wxPyRestoreThread(); \
+ if (m_myInst.findCallback(#CBNAME)) \
+ m_myInst.callCallback(Py_BuildValue("()")); \
+ wxPySaveThread(doSave); \
+ }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_wxSize__pure(CBNAME) \
+ wxSize CBNAME(); \
+
+
+#define IMP_PYCALLBACK_wxSize__pure(CLASS, PCLASS, CBNAME) \
+ wxSize CLASS::CBNAME() { \
+ wxSize rval(0,0); \
+ bool doSave = wxPyRestoreThread(); \
+ if (m_myInst.findCallback(#CBNAME)) { \
+ PyObject* ro; \
+ wxSize* ptr; \
+ ro = m_myInst.callCallbackObj(Py_BuildValue("()")); \
+ if (! SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p")) \
+ rval = *ptr; \
+ } \
+ wxPySaveThread(doSave); \
+ return rval; \
+ }
+
+//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BOOL_WXWIN(CBNAME) \
+ bool CBNAME(wxWindow* a); \
+ bool base_##CBNAME(wxWindow* a);
+
+
+#define IMP_PYCALLBACK_BOOL_WXWIN(CLASS, PCLASS, CBNAME) \
+ bool CLASS::CBNAME(wxWindow* a) { \
+ bool rval; \
+ bool doSave = wxPyRestoreThread(); \
+ if (m_myInst.findCallback(#CBNAME)) \
+ rval = m_myInst.callCallback(Py_BuildValue("(O)", \
+ wxPyConstructObject((void*)a,"wxWindow"))); \
+ else \
+ rval = PCLASS::CBNAME(a); \
+ wxPySaveThread(doSave); \
+ return rval; \
+ } \
+ bool CLASS::base_##CBNAME(wxWindow* a) { \
+ return PCLASS::CBNAME(a); \
+ }
+
//---------------------------------------------------------------------------
+
+#define DEC_PYCALLBACK_BOOL_(CBNAME) \
+ bool CBNAME(); \
+ bool base_##CBNAME();
+
+
+#define IMP_PYCALLBACK_BOOL_(CLASS, PCLASS, CBNAME) \
+ bool CLASS::CBNAME() { \
+ bool rval; \
+ bool doSave = wxPyRestoreThread(); \
+ if (m_myInst.findCallback(#CBNAME)) \
+ rval = m_myInst.callCallback(Py_BuildValue("()")); \
+ else \
+ rval = PCLASS::CBNAME(); \
+ wxPySaveThread(doSave); \
+ return rval; \
+ } \
+ bool CLASS::base_##CBNAME() { \
+ return PCLASS::CBNAME(); \
+ }
+
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class wxAcceleratorEntry {
public:
wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
- //~wxAcceleratorEntry(); *** ?
+ ~wxAcceleratorEntry();
void Set(int flags, int keyCode, int Cmd);
int GetFlags();
public:
// Can also accept a list of 3-tuples
wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* LIST);
- // ~wxAcceleratorEntry(); *** ?
+ ~wxAcceleratorTable();
};
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __cplusplus
extern "C" {
long _arg3 = (long ) 0;
wxPoint * _arg4 = (wxPoint *) &wxPyDefaultPosition;
PyObject * _argo0 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","message","defaultPath","style","pos", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|sslO:new_wxDirDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_argo4))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|sslO:new_wxDirDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_obj4))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxDirDialog. Expected _wxPoint_p.");
+ if (_obj4)
+{
+ _arg4 = &temp;
+ if (! wxPoint_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxDirDialog *)new_wxDirDialog(_arg0,_arg1,_arg2,_arg3,*_arg4);
long _arg5 = (long ) 0;
wxPoint * _arg6 = (wxPoint *) &wxPyDefaultPosition;
PyObject * _argo0 = 0;
- PyObject * _argo6 = 0;
+ wxPoint temp;
+ PyObject * _obj6 = 0;
char *_kwnames[] = { "parent","message","defaultDir","defaultFile","wildcard","style","pos", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|sssslO:new_wxFileDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_argo6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|sssslO:new_wxFileDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_obj6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo6) {
- if (_argo6 == Py_None) { _arg6 = NULL; }
- else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of new_wxFileDialog. Expected _wxPoint_p.");
+ if (_obj6)
+{
+ _arg6 = &temp;
+ if (! wxPoint_helper(_obj6, &_arg6))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxFileDialog *)new_wxFileDialog(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,*_arg6);
PyObject * _obj1 = 0;
PyObject * _obj2 = 0;
PyObject * _obj4 = 0;
- PyObject * _argo6 = 0;
+ wxPoint temp;
+ PyObject * _obj6 = 0;
char *_kwnames[] = { "parent","message","caption","LIST","style","pos", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO|lO:new_wxSingleChoiceDialog",_kwnames,&_argo0,&_obj1,&_obj2,&_obj4,&_arg5,&_argo6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO|lO:new_wxSingleChoiceDialog",_kwnames,&_argo0,&_obj1,&_obj2,&_obj4,&_arg5,&_obj6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo6) {
- if (_argo6 == Py_None) { _arg6 = NULL; }
- else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of new_wxSingleChoiceDialog. Expected _wxPoint_p.");
+ if (_obj6)
+{
+ _arg6 = &temp;
+ if (! wxPoint_helper(_obj6, &_arg6))
return NULL;
- }
- }
+}
{
if (_obj4) {
_arg3 = PyList_Size(_obj4);
long _arg4 = (long ) wxOK|wxCANCEL|wxCENTRE;
wxPoint * _arg5 = (wxPoint *) &wxPyDefaultPosition;
PyObject * _argo0 = 0;
- PyObject * _argo5 = 0;
+ wxPoint temp;
+ PyObject * _obj5 = 0;
char *_kwnames[] = { "parent","message","caption","defaultValue","style","pos", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os|sslO:new_wxTextEntryDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_argo5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os|sslO:new_wxTextEntryDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_obj5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo5) {
- if (_argo5 == Py_None) { _arg5 = NULL; }
- else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of new_wxTextEntryDialog. Expected _wxPoint_p.");
+ if (_obj5)
+{
+ _arg5 = &temp;
+ if (! wxPoint_helper(_obj5, &_arg5))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxTextEntryDialog *)new_wxTextEntryDialog(_arg0,_arg1,_arg2,_arg3,_arg4,*_arg5);
long _arg3 = (long ) wxOK|wxCANCEL|wxCENTRE;
wxPoint * _arg4 = (wxPoint *) &wxPyDefaultPosition;
PyObject * _argo0 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","message","caption","style","pos", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os|slO:new_wxMessageDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_argo4))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os|slO:new_wxMessageDialog",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_obj4))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMessageDialog. Expected _wxPoint_p.");
+ if (_obj4)
+{
+ _arg4 = &temp;
+ if (! wxPoint_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxMessageDialog *)new_wxMessageDialog(_arg0,_arg1,_arg2,_arg3,*_arg4);
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxCheckListBox","_class_wxCheckListBox",0},
{ "_wxRect","_class_wxRect",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
{ "_wxMessageDialog","_class_wxMessageDialog",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_wxTextEntryDialog","_class_wxTextEntryDialog",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_wxSize","_class_wxSize",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_wxControl",0},
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
wxValidator wxPyDefaultValidator; // Non-const default because of SWIG
#ifdef __cplusplus
extern "C" {
#endif
+static int _wrap_wxDefaultValidator_set(PyObject *val) {
+
+ PyErr_SetString(PyExc_TypeError,"Variable wxDefaultValidator is read-only.");
+ return 1;
+}
+
+static PyObject *_wrap_wxDefaultValidator_get() {
+ PyObject * pyobj;
+ char ptemp[128];
+
+ SWIG_MakePtr(ptemp,(char *) &wxDefaultValidator,"_wxValidator_p");
+ pyobj = PyString_FromString(ptemp);
+ return pyobj;
+}
+
static void *SwigwxControlTowxWindow(void *ptr) {
wxControl *src;
wxWindow *dest;
char * _arg7 = (char *) "button";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _argo6 = 0;
char *_kwnames[] = { "parent","id","label","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxButton",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_argo6,&_arg7))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxButton",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_argo6,&_arg7))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxButton. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxButton. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_argo6) {
if (_argo6 == Py_None) { _arg6 = NULL; }
else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxValidator_p")) {
char * _arg7 = (char *) "button";
PyObject * _argo0 = 0;
PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _argo6 = 0;
char *_kwnames[] = { "parent","id","bitmap","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxBitmapButton",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_argo4,&_arg5,&_argo6,&_arg7))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxBitmapButton",_kwnames,&_argo0,&_arg1,&_argo2,&_obj3,&_obj4,&_arg5,&_argo6,&_arg7))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxBitmapButton. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxBitmapButton. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_argo6) {
if (_argo6 == Py_None) { _arg6 = NULL; }
else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxValidator_p")) {
char * _arg7 = (char *) "checkBox";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _argo6 = 0;
char *_kwnames[] = { "parent","id","label","pos","size","style","val","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxCheckBox",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_argo6,&_arg7))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxCheckBox",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_argo6,&_arg7))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxCheckBox. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxCheckBox. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_argo6) {
if (_argo6 == Py_None) { _arg6 = NULL; }
else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxValidator_p")) {
wxValidator * _arg7 = (wxValidator *) &wxPyDefaultValidator;
char * _arg8 = (char *) "choice";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
PyObject * _obj5 = 0;
PyObject * _argo7 = 0;
char *_kwnames[] = { "parent","id","pos","size","LIST","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOOlOs:new_wxChoice",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_obj5,&_arg6,&_argo7,&_arg8))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOOlOs:new_wxChoice",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj5,&_arg6,&_argo7,&_arg8))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxChoice. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxChoice. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
if (_obj5)
{
_arg5 = wxString_LIST_helper(_obj5);
wxValidator * _arg8 = (wxValidator *) &wxPyDefaultValidator;
char * _arg9 = (char *) "comboBox";
PyObject * _argo0 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _obj6 = 0;
PyObject * _argo8 = 0;
char *_kwnames[] = { "parent","id","value","pos","size","LIST","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|sOOOlOs:new_wxComboBox",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3,&_argo4,&_obj6,&_arg7,&_argo8,&_arg9))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|sOOOlOs:new_wxComboBox",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3,&_obj4,&_obj6,&_arg7,&_argo8,&_arg9))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxComboBox. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxComboBox. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_obj6)
{
_arg6 = wxString_LIST_helper(_obj6);
wxValidator * _arg6 = (wxValidator *) &wxPyDefaultValidator;
char * _arg7 = (char *) "gauge";
PyObject * _argo0 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _argo6 = 0;
char *_kwnames[] = { "parent","id","range","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|OOlOs:new_wxGauge",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3,&_argo4,&_arg5,&_argo6,&_arg7))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|OOlOs:new_wxGauge",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3,&_obj4,&_arg5,&_argo6,&_arg7))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxGauge. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxGauge. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_argo6) {
if (_argo6 == Py_None) { _arg6 = NULL; }
else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxValidator_p")) {
char * _arg6 = (char *) "staticBox";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","label","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxStaticBox",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxStaticBox",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxStaticBox. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxStaticBox. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxStaticBox *)new_wxStaticBox(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
long _arg4 = (long ) wxLI_HORIZONTAL;
char * _arg5 = (char *) "staticLine";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxStaticLine",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxStaticLine",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxStaticLine. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxStaticLine. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxStaticLine *)new_wxStaticLine(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
char * _arg6 = (char *) "staticText";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","label","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxStaticText",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxStaticText",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxStaticText. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxStaticText. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxStaticText *)new_wxStaticText(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
wxValidator * _arg7 = (wxValidator *) &wxPyDefaultValidator;
char * _arg8 = (char *) "listBox";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
PyObject * _obj5 = 0;
PyObject * _argo7 = 0;
char *_kwnames[] = { "parent","id","pos","size","LIST","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOOlOs:new_wxListBox",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_obj5,&_arg6,&_argo7,&_arg8))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOOlOs:new_wxListBox",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj5,&_arg6,&_argo7,&_arg8))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxListBox. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxListBox. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
if (_obj5)
{
_arg5 = wxString_LIST_helper(_obj5);
return _resultobj;
}
+#define wxListBox_InsertItems(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->InsertItems(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_wxListBox_InsertItems(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxListBox * _arg0;
+ int _arg1;
+ wxString * _arg2;
+ int _arg3;
+ PyObject * _argo0 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","LIST","pos", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxListBox_InsertItems",_kwnames,&_argo0,&_obj2,&_arg3))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxListBox_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxListBox_InsertItems. Expected _wxListBox_p.");
+ return NULL;
+ }
+ }
+{
+ _arg2 = wxString_LIST_helper(_obj2);
+ if (_arg2 == NULL) {
+ return NULL;
+ }
+}
+{
+ if (_obj2) {
+ _arg1 = PyList_Size(_obj2);
+ }
+ else {
+ _arg1 = 0;
+ }
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxListBox_InsertItems(_arg0,_arg1,_arg2,_arg3);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ delete [] _arg2;
+}
+ return _resultobj;
+}
+
#define wxListBox_GetString(_swigobj,_swigarg0) (_swigobj->GetString(_swigarg0))
static PyObject *_wrap_wxListBox_GetString(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxValidator * _arg7 = (wxValidator *) &wxPyDefaultValidator;
char * _arg8 = (char *) "listBox";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
PyObject * _obj5 = 0;
PyObject * _argo7 = 0;
char *_kwnames[] = { "parent","id","pos","size","LIST","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOOlOs:new_wxCheckListBox",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_obj5,&_arg6,&_argo7,&_arg8))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOOlOs:new_wxCheckListBox",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj5,&_arg6,&_argo7,&_arg8))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxCheckListBox. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxCheckListBox. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
if (_obj5)
{
_arg5 = wxString_LIST_helper(_obj5);
wxValidator * _arg6 = (wxValidator *) &wxPyDefaultValidator;
char * _arg7 = (char *) "text";
PyObject * _argo0 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _argo6 = 0;
char *_kwnames[] = { "parent","id","value","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|sOOlOs:new_wxTextCtrl",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3,&_argo4,&_arg5,&_argo6,&_arg7))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|sOOlOs:new_wxTextCtrl",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3,&_obj4,&_arg5,&_argo6,&_arg7))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxTextCtrl. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxTextCtrl. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_argo6) {
if (_argo6 == Py_None) { _arg6 = NULL; }
else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxValidator_p")) {
wxValidator * _arg5 = (wxValidator *) &wxPyDefaultValidator;
char * _arg6 = (char *) "scrollBar";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
PyObject * _argo5 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOlOs:new_wxScrollBar",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_argo5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOlOs:new_wxScrollBar",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_argo5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxScrollBar. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxScrollBar. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
if (_argo5) {
if (_argo5 == Py_None) { _arg5 = NULL; }
else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxValidator_p")) {
long _arg4 = (long ) wxSP_HORIZONTAL;
char * _arg5 = (char *) "spinButton";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOls:new_wxSpinButton",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOls:new_wxSpinButton",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxSpinButton. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxSpinButton. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxSpinButton *)new_wxSpinButton(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
char * _arg6 = (char *) "staticBitmap";
PyObject * _argo0 = 0;
PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","bitmap","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxStaticBitmap",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxStaticBitmap",_kwnames,&_argo0,&_arg1,&_argo2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxStaticBitmap. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxStaticBitmap. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxStaticBitmap *)new_wxStaticBitmap(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
char * _arg10 = (char *) "radioBox";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _obj6 = 0;
PyObject * _argo9 = 0;
char *_kwnames[] = { "parent","id","label","point","size","LIST","majorDimension","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOOilOs:new_wxRadioBox",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_obj6,&_arg7,&_arg8,&_argo9,&_arg10))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOOilOs:new_wxRadioBox",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_obj6,&_arg7,&_arg8,&_argo9,&_arg10))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxRadioBox. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxRadioBox. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_obj6)
{
_arg6 = wxString_LIST_helper(_obj6);
char * _arg7 = (char *) "radioButton";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
PyObject * _argo6 = 0;
char *_kwnames[] = { "parent","id","label","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxRadioButton",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_argo6,&_arg7))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOlOs:new_wxRadioButton",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_argo6,&_arg7))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxRadioButton. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxRadioButton. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
if (_argo6) {
if (_argo6 == Py_None) { _arg6 = NULL; }
else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxValidator_p")) {
wxValidator * _arg8 = (wxValidator *) &wxPyDefaultValidator;
char * _arg9 = (char *) "slider";
PyObject * _argo0 = 0;
- PyObject * _argo5 = 0;
- PyObject * _argo6 = 0;
+ wxPoint temp;
+ PyObject * _obj5 = 0;
+ wxSize temp0;
+ PyObject * _obj6 = 0;
PyObject * _argo8 = 0;
char *_kwnames[] = { "parent","id","value","minValue","maxValue","point","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|OOlOs:new_wxSlider",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_argo5,&_argo6,&_arg7,&_argo8,&_arg9))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|OOlOs:new_wxSlider",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_obj5,&_obj6,&_arg7,&_argo8,&_arg9))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo5) {
- if (_argo5 == Py_None) { _arg5 = NULL; }
- else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of new_wxSlider. Expected _wxPoint_p.");
+ if (_obj5)
+{
+ _arg5 = &temp;
+ if (! wxPoint_helper(_obj5, &_arg5))
return NULL;
- }
- }
- if (_argo6) {
- if (_argo6 == Py_None) { _arg6 = NULL; }
- else if (SWIG_GetPtrObj(_argo6,(void **) &_arg6,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 7 of new_wxSlider. Expected _wxSize_p.");
+}
+ if (_obj6)
+{
+ _arg6 = &temp0;
+ if (! wxSize_helper(_obj6, &_arg6))
return NULL;
- }
- }
+}
if (_argo8) {
if (_argo8 == Py_None) { _arg8 = NULL; }
else if (SWIG_GetPtrObj(_argo8,(void **) &_arg8,"_wxValidator_p")) {
{ "wxListBox_Number", (PyCFunction) _wrap_wxListBox_Number, METH_VARARGS | METH_KEYWORDS },
{ "wxListBox_GetStringSelection", (PyCFunction) _wrap_wxListBox_GetStringSelection, METH_VARARGS | METH_KEYWORDS },
{ "wxListBox_GetString", (PyCFunction) _wrap_wxListBox_GetString, METH_VARARGS | METH_KEYWORDS },
+ { "wxListBox_InsertItems", (PyCFunction) _wrap_wxListBox_InsertItems, METH_VARARGS | METH_KEYWORDS },
{ "wxListBox_GetSelections", (PyCFunction) _wrap_wxListBox_GetSelections, METH_VARARGS | METH_KEYWORDS },
{ "wxListBox_GetSelection", (PyCFunction) _wrap_wxListBox_GetSelection, METH_VARARGS | METH_KEYWORDS },
{ "wxListBox_FindString", (PyCFunction) _wrap_wxListBox_FindString, METH_VARARGS | METH_KEYWORDS },
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxCheckListBox","_class_wxCheckListBox",0},
{ "_wxRect","_class_wxRect",0},
{ "_wxSpinButton","_class_wxSpinButton",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticBitmap","_wxStaticBitmap",0},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxBitmapButton",SwigwxBitmapButtonTowxButton},
{ "_wxButton","_wxBitmapButton",SwigwxBitmapButtonTowxButton},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_class_wxSlider",SwigwxSliderTowxControl},
SWIG_globals = SWIG_newvarlink();
m = Py_InitModule("controlsc", controlscMethods);
d = PyModule_GetDict(m);
+ PyDict_SetItemString(d,"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,"wxDefaultValidator",_wrap_wxDefaultValidator_get, _wrap_wxDefaultValidator_set);
{
int i;
for (i = 0; _swig_mapping[i].n1; i++)
def GetSelections(self, *_args, **_kwargs):
val = apply(controlsc.wxListBox_GetSelections,(self,) + _args, _kwargs)
return val
+ def InsertItems(self, *_args, **_kwargs):
+ val = apply(controlsc.wxListBox_InsertItems,(self,) + _args, _kwargs)
+ return val
def GetString(self, *_args, **_kwargs):
val = apply(controlsc.wxListBox_GetString,(self,) + _args, _kwargs)
return val
#-------------- VARIABLE WRAPPERS ------------------
+cvar = controlsc.cvar
+wxDefaultValidator = wxValidatorPtr(controlsc.cvar.wxDefaultValidator)
#define SWIG_name "controls2c"
#include "helpers.h"
+#ifdef __WXMSW__
+#include <windows.h>
+#endif
#include <wx/listctrl.h>
#include <wx/treectrl.h>
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
extern wxValidator wxPyDefaultValidator;
wxListEvent * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","m_pointDrag", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxListEvent_m_pointDrag_set",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxListEvent_m_pointDrag_set",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxListEvent_m_pointDrag_set. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxPoint *)wxListEvent_m_pointDrag_set(_arg0,_arg1);
wxValidator * _arg5 = (wxValidator *) &wxPyDefaultValidator;
char * _arg6 = (char *) "listCtrl";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
PyObject * _argo5 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOlOs:new_wxListCtrl",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_argo5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOlOs:new_wxListCtrl",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_argo5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxListCtrl. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxListCtrl. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
if (_argo5) {
if (_argo5 == Py_None) { _arg5 = NULL; }
else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxValidator_p")) {
wxPoint * _arg2;
int _arg3;
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
char *_kwnames[] = { "self","start","pt","direction", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OlOi:wxListCtrl_FindItemAtPos",_kwnames,&_argo0,&_arg1,&_argo2,&_arg3))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OlOi:wxListCtrl_FindItemAtPos",_kwnames,&_argo0,&_arg1,&_obj2,&_arg3))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxListCtrl_FindItemAtPos. Expected _wxPoint_p.");
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxListCtrl_FindItemAtPos(_arg0,_arg1,*_arg2,_arg3);
int * _arg2;
int temp;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp0;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","point", NULL };
self = self;
{
_arg2 = &temp;
}
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxListCtrl_HitTest",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxListCtrl_HitTest",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxListCtrl_HitTest. Expected _wxPoint_p.");
+{
+ _arg1 = &temp0;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxListCtrl_HitTest(_arg0,*_arg1,*_arg2);
long _arg1;
wxPoint * _arg2;
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
char *_kwnames[] = { "self","item","pos", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OlO:wxListCtrl_SetItemPosition",_kwnames,&_argo0,&_arg1,&_argo2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OlO:wxListCtrl_SetItemPosition",_kwnames,&_argo0,&_arg1,&_obj2))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxListCtrl_SetItemPosition. Expected _wxPoint_p.");
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxListCtrl_SetItemPosition(_arg0,_arg1,*_arg2);
wxValidator * _arg5 = (wxValidator *) &wxPyDefaultValidator;
char * _arg6 = (char *) "wxTreeCtrl";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
PyObject * _argo5 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","validator","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOlOs:new_wxTreeCtrl",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_argo5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOlOs:new_wxTreeCtrl",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_argo5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxTreeCtrl. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxTreeCtrl. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
if (_argo5) {
if (_argo5 == Py_None) { _arg5 = NULL; }
else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxValidator_p")) {
wxTreeCtrl * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","point", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxTreeCtrl_HitTest",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxTreeCtrl_HitTest",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_HitTest. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxTreeItemId (wxTreeCtrl_HitTest(_arg0,*_arg1));
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_class_wxTreeEvent",SwigwxTreeEventTowxEvent},
{ "_class_wxEvent","_wxTreeEvent",SwigwxTreeEventTowxEvent},
{ "_class_wxEvent","_class_wxListEvent",SwigwxListEventTowxEvent},
{ "_class_wxNotifyEvent","_class_wxTreeEvent",SwigwxTreeEventTowxNotifyEvent},
{ "_class_wxNotifyEvent","_wxTreeEvent",SwigwxTreeEventTowxNotifyEvent},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticBitmap","_wxStaticBitmap",0},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxListEvent","_wxListEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxTreeItemId","_wxTreeItemId",0},
{ "_wxTreeCtrl","_class_wxTreeCtrl",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
return target;
}
+static char* wxStringErrorMsg = "string type is required for parameter";
+
+class wxPyEvent : public wxEvent {
+ DECLARE_DYNAMIC_CLASS(wxPyEvent)
+public:
+ wxPyEvent(int id=0, PyObject* userData = Py_None)
+ : wxEvent(id) {
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ }
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+ ~wxPyEvent() {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+ void SetPyData(PyObject* userData) {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+
+ PyObject* GetPyData() const {
+ Py_INCREF(m_userData);
+ return m_userData;
+ }
+
+ // This one is so the event object can be Cloned...
+ void CopyObject(wxObject& dest) const {
+ wxEvent::CopyObject(dest);
+ ((wxPyEvent*)&dest)->SetPyData(m_userData);
+ }
+
+private:
+ PyObject* m_userData;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxPyEvent, wxEvent)
+
+
+class wxPyCommandEvent : public wxCommandEvent {
+ DECLARE_DYNAMIC_CLASS(wxPyCommandEvent)
+public:
+ wxPyCommandEvent(wxEventType commandType = wxEVT_NULL, int id=0, PyObject* userData = Py_None)
+ : wxCommandEvent(commandType, id) {
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ }
+
+ ~wxPyCommandEvent() {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+
+ void SetPyData(PyObject* userData) {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_userData);
+ m_userData = userData;
+ Py_INCREF(m_userData);
+ wxPySaveThread(doSave);
+ }
+
+ PyObject* GetPyData() const {
+ Py_INCREF(m_userData);
+ return m_userData;
+ }
+
+ // This one is so the event object can be Cloned...
+ void CopyObject(wxObject& dest) const {
+ wxCommandEvent::CopyObject(dest);
+ ((wxPyCommandEvent*)&dest)->SetPyData(m_userData);
+ }
+
+private:
+ PyObject* m_userData;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxPyCommandEvent, wxCommandEvent)
-static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __cplusplus
extern "C" {
#endif
wxJoystickEvent * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pos", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxJoystickEvent_SetPosition",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxJoystickEvent_SetPosition",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxJoystickEvent_SetPosition. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxJoystickEvent_SetPosition(_arg0,*_arg1);
return (void *) dest;
}
-static void *SwigwxPyEventTowxCommandEvent(void *ptr) {
- wxPyEvent *src;
+static void *SwigwxNotifyEventTowxCommandEvent(void *ptr) {
+ wxNotifyEvent *src;
wxCommandEvent *dest;
- src = (wxPyEvent *) ptr;
+ src = (wxNotifyEvent *) ptr;
dest = (wxCommandEvent *) src;
return (void *) dest;
}
+static void *SwigwxNotifyEventTowxEvent(void *ptr) {
+ wxNotifyEvent *src;
+ wxEvent *dest;
+ src = (wxNotifyEvent *) ptr;
+ dest = (wxEvent *) src;
+ return (void *) dest;
+}
+
+#define wxNotifyEvent_IsAllowed(_swigobj) (_swigobj->IsAllowed())
+static PyObject *_wrap_wxNotifyEvent_IsAllowed(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxNotifyEvent * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxNotifyEvent_IsAllowed",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxNotifyEvent_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotifyEvent_IsAllowed. Expected _wxNotifyEvent_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxNotifyEvent_IsAllowed(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxNotifyEvent_Veto(_swigobj) (_swigobj->Veto())
+static PyObject *_wrap_wxNotifyEvent_Veto(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxNotifyEvent * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxNotifyEvent_Veto",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxNotifyEvent_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotifyEvent_Veto. Expected _wxNotifyEvent_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxNotifyEvent_Veto(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
static void *SwigwxPyEventTowxEvent(void *ptr) {
wxPyEvent *src;
wxEvent *dest;
static PyObject *_wrap_new_wxPyEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxPyEvent * _result;
- wxEventType _arg0 = (wxEventType ) wxEVT_NULL;
+ int _arg0 = (int ) 0;
PyObject * _arg1 = (PyObject *) Py_None;
PyObject * _obj1 = 0;
- char *_kwnames[] = { "commandType","userData", NULL };
+ char *_kwnames[] = { "id","userData", NULL };
char _ptemp[128];
self = self;
return _resultobj;
}
-#define wxPyEvent_SetUserData(_swigobj,_swigarg0) (_swigobj->SetUserData(_swigarg0))
-static PyObject *_wrap_wxPyEvent_SetUserData(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxPyEvent_SetPyData(_swigobj,_swigarg0) (_swigobj->SetPyData(_swigarg0))
+static PyObject *_wrap_wxPyEvent_SetPyData(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxPyEvent * _arg0;
PyObject * _arg1;
char *_kwnames[] = { "self","userData", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyEvent_SetUserData",_kwnames,&_argo0,&_obj1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyEvent_SetPyData",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyEvent_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyEvent_SetUserData. Expected _wxPyEvent_p.");
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyEvent_SetPyData. Expected _wxPyEvent_p.");
return NULL;
}
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
- wxPyEvent_SetUserData(_arg0,_arg1);
+ wxPyEvent_SetPyData(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
return _resultobj;
}
-#define wxPyEvent_GetUserData(_swigobj) (_swigobj->GetUserData())
-static PyObject *_wrap_wxPyEvent_GetUserData(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxPyEvent_GetPyData(_swigobj) (_swigobj->GetPyData())
+static PyObject *_wrap_wxPyEvent_GetPyData(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
PyObject * _result;
wxPyEvent * _arg0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyEvent_GetUserData",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyEvent_GetPyData",_kwnames,&_argo0))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyEvent_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyEvent_GetUserData. Expected _wxPyEvent_p.");
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyEvent_GetPyData. Expected _wxPyEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
- _result = (PyObject *)wxPyEvent_GetUserData(_arg0);
+ _result = (PyObject *)wxPyEvent_GetPyData(_arg0);
wxPy_END_ALLOW_THREADS;
}{
return _resultobj;
}
-static void *SwigwxNotifyEventTowxCommandEvent(void *ptr) {
- wxNotifyEvent *src;
+static void *SwigwxPyCommandEventTowxCommandEvent(void *ptr) {
+ wxPyCommandEvent *src;
wxCommandEvent *dest;
- src = (wxNotifyEvent *) ptr;
+ src = (wxPyCommandEvent *) ptr;
dest = (wxCommandEvent *) src;
return (void *) dest;
}
-static void *SwigwxNotifyEventTowxEvent(void *ptr) {
- wxNotifyEvent *src;
+static void *SwigwxPyCommandEventTowxEvent(void *ptr) {
+ wxPyCommandEvent *src;
wxEvent *dest;
- src = (wxNotifyEvent *) ptr;
+ src = (wxPyCommandEvent *) ptr;
dest = (wxEvent *) src;
return (void *) dest;
}
-#define wxNotifyEvent_IsAllowed(_swigobj) (_swigobj->IsAllowed())
-static PyObject *_wrap_wxNotifyEvent_IsAllowed(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define new_wxPyCommandEvent(_swigarg0,_swigarg1,_swigarg2) (new wxPyCommandEvent(_swigarg0,_swigarg1,_swigarg2))
+static PyObject *_wrap_new_wxPyCommandEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
- bool _result;
- wxNotifyEvent * _arg0;
+ wxPyCommandEvent * _result;
+ wxEventType _arg0 = (wxEventType ) wxEVT_NULL;
+ int _arg1 = (int ) 0;
+ PyObject * _arg2 = (PyObject *) Py_None;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "commandType","id","userData", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|iiO:new_wxPyCommandEvent",_kwnames,&_arg0,&_arg1,&_obj2))
+ return NULL;
+ if (_obj2)
+{
+ _arg2 = _obj2;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxPyCommandEvent *)new_wxPyCommandEvent(_arg0,_arg1,_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyCommandEvent_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define delete_wxPyCommandEvent(_swigobj) (delete _swigobj)
+static PyObject *_wrap_delete_wxPyCommandEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxPyCommandEvent * _arg0;
PyObject * _argo0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxNotifyEvent_IsAllowed",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxPyCommandEvent",_kwnames,&_argo0))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxNotifyEvent_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotifyEvent_IsAllowed. Expected _wxNotifyEvent_p.");
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyCommandEvent_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxPyCommandEvent. Expected _wxPyCommandEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
- _result = (bool )wxNotifyEvent_IsAllowed(_arg0);
+ delete_wxPyCommandEvent(_arg0);
wxPy_END_ALLOW_THREADS;
-} _resultobj = Py_BuildValue("i",_result);
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
return _resultobj;
}
-#define wxNotifyEvent_Veto(_swigobj) (_swigobj->Veto())
-static PyObject *_wrap_wxNotifyEvent_Veto(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxPyCommandEvent_SetPyData(_swigobj,_swigarg0) (_swigobj->SetPyData(_swigarg0))
+static PyObject *_wrap_wxPyCommandEvent_SetPyData(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
- wxNotifyEvent * _arg0;
+ wxPyCommandEvent * _arg0;
+ PyObject * _arg1;
PyObject * _argo0 = 0;
- char *_kwnames[] = { "self", NULL };
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","userData", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxNotifyEvent_Veto",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyCommandEvent_SetPyData",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxNotifyEvent_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotifyEvent_Veto. Expected _wxNotifyEvent_p.");
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyCommandEvent_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyCommandEvent_SetPyData. Expected _wxPyCommandEvent_p.");
return NULL;
}
}
+{
+ _arg1 = _obj1;
+}
{
wxPy_BEGIN_ALLOW_THREADS;
- wxNotifyEvent_Veto(_arg0);
+ wxPyCommandEvent_SetPyData(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
return _resultobj;
}
+#define wxPyCommandEvent_GetPyData(_swigobj) (_swigobj->GetPyData())
+static PyObject *_wrap_wxPyCommandEvent_GetPyData(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ PyObject * _result;
+ wxPyCommandEvent * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyCommandEvent_GetPyData",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyCommandEvent_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyCommandEvent_GetPyData. Expected _wxPyCommandEvent_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (PyObject *)wxPyCommandEvent_GetPyData(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = _result;
+}
+ return _resultobj;
+}
+
static PyMethodDef eventscMethods[] = {
- { "wxNotifyEvent_Veto", (PyCFunction) _wrap_wxNotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS },
- { "wxNotifyEvent_IsAllowed", (PyCFunction) _wrap_wxNotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS },
- { "wxPyEvent_GetUserData", (PyCFunction) _wrap_wxPyEvent_GetUserData, METH_VARARGS | METH_KEYWORDS },
- { "wxPyEvent_SetUserData", (PyCFunction) _wrap_wxPyEvent_SetUserData, METH_VARARGS | METH_KEYWORDS },
+ { "wxPyCommandEvent_GetPyData", (PyCFunction) _wrap_wxPyCommandEvent_GetPyData, METH_VARARGS | METH_KEYWORDS },
+ { "wxPyCommandEvent_SetPyData", (PyCFunction) _wrap_wxPyCommandEvent_SetPyData, METH_VARARGS | METH_KEYWORDS },
+ { "delete_wxPyCommandEvent", (PyCFunction) _wrap_delete_wxPyCommandEvent, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxPyCommandEvent", (PyCFunction) _wrap_new_wxPyCommandEvent, METH_VARARGS | METH_KEYWORDS },
+ { "wxPyEvent_GetPyData", (PyCFunction) _wrap_wxPyEvent_GetPyData, METH_VARARGS | METH_KEYWORDS },
+ { "wxPyEvent_SetPyData", (PyCFunction) _wrap_wxPyEvent_SetPyData, METH_VARARGS | METH_KEYWORDS },
{ "delete_wxPyEvent", (PyCFunction) _wrap_delete_wxPyEvent, METH_VARARGS | METH_KEYWORDS },
{ "new_wxPyEvent", (PyCFunction) _wrap_new_wxPyEvent, METH_VARARGS | METH_KEYWORDS },
+ { "wxNotifyEvent_Veto", (PyCFunction) _wrap_wxNotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS },
+ { "wxNotifyEvent_IsAllowed", (PyCFunction) _wrap_wxNotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS },
{ "wxUpdateUIEvent_SetText", (PyCFunction) _wrap_wxUpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS },
{ "wxUpdateUIEvent_Enable", (PyCFunction) _wrap_wxUpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS },
{ "wxUpdateUIEvent_Check", (PyCFunction) _wrap_wxUpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS },
*/
static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
{ "_wxAcceleratorTable","_class_wxAcceleratorTable",0},
- { "_wxEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
- { "_wxEvent","_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
+ { "_wxEvent","_class_wxPyCommandEvent",SwigwxPyCommandEventTowxEvent},
+ { "_wxEvent","_wxPyCommandEvent",SwigwxPyCommandEventTowxEvent},
{ "_wxEvent","_class_wxPyEvent",SwigwxPyEventTowxEvent},
{ "_wxEvent","_wxPyEvent",SwigwxPyEventTowxEvent},
+ { "_wxEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
+ { "_wxEvent","_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
{ "_wxEvent","_class_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent},
{ "_wxEvent","_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent},
{ "_wxEvent","_class_wxUpdateUIEvent",SwigwxUpdateUIEventTowxEvent},
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
- { "_class_wxEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
- { "_class_wxEvent","_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
+ { "_class_wxEvent","_class_wxPyCommandEvent",SwigwxPyCommandEventTowxEvent},
+ { "_class_wxEvent","_wxPyCommandEvent",SwigwxPyCommandEventTowxEvent},
{ "_class_wxEvent","_class_wxPyEvent",SwigwxPyEventTowxEvent},
{ "_class_wxEvent","_wxPyEvent",SwigwxPyEventTowxEvent},
+ { "_class_wxEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
+ { "_class_wxEvent","_wxNotifyEvent",SwigwxNotifyEventTowxEvent},
{ "_class_wxEvent","_class_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent},
{ "_class_wxEvent","_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent},
{ "_class_wxEvent","_class_wxUpdateUIEvent",SwigwxUpdateUIEventTowxEvent},
{ "_class_wxEvent","_wxSizeEvent",SwigwxSizeEventTowxEvent},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxRect","_class_wxRect",0},
+ { "_wxCommandEvent","_class_wxPyCommandEvent",SwigwxPyCommandEventTowxCommandEvent},
+ { "_wxCommandEvent","_wxPyCommandEvent",SwigwxPyCommandEventTowxCommandEvent},
{ "_wxCommandEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent},
{ "_wxCommandEvent","_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent},
- { "_wxCommandEvent","_class_wxPyEvent",SwigwxPyEventTowxCommandEvent},
- { "_wxCommandEvent","_wxPyEvent",SwigwxPyEventTowxCommandEvent},
{ "_wxCommandEvent","_class_wxSpinEvent",SwigwxSpinEventTowxCommandEvent},
{ "_wxCommandEvent","_wxSpinEvent",SwigwxSpinEventTowxCommandEvent},
{ "_wxCommandEvent","_class_wxScrollEvent",SwigwxScrollEventTowxCommandEvent},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxSize","_class_wxSize",0},
{ "_wxRegionIterator","_class_wxRegionIterator",0},
{ "_wxRegion","_class_wxRegion",0},
{ "_class_wxShowEvent","_wxShowEvent",0},
{ "_wxActivateEvent","_class_wxActivateEvent",0},
+ { "_class_wxCommandEvent","_class_wxPyCommandEvent",SwigwxPyCommandEventTowxCommandEvent},
+ { "_class_wxCommandEvent","_wxPyCommandEvent",SwigwxPyCommandEventTowxCommandEvent},
{ "_class_wxCommandEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent},
{ "_class_wxCommandEvent","_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent},
- { "_class_wxCommandEvent","_class_wxPyEvent",SwigwxPyEventTowxCommandEvent},
- { "_class_wxCommandEvent","_wxPyEvent",SwigwxPyEventTowxCommandEvent},
{ "_class_wxCommandEvent","_class_wxSpinEvent",SwigwxSpinEventTowxCommandEvent},
{ "_class_wxCommandEvent","_wxSpinEvent",SwigwxSpinEventTowxCommandEvent},
{ "_class_wxCommandEvent","_class_wxScrollEvent",SwigwxScrollEventTowxCommandEvent},
-class wxPyEventPtr(wxCommandEventPtr):
+class wxNotifyEventPtr(wxCommandEventPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def IsAllowed(self, *_args, **_kwargs):
+ val = apply(eventsc.wxNotifyEvent_IsAllowed,(self,) + _args, _kwargs)
+ return val
+ def Veto(self, *_args, **_kwargs):
+ val = apply(eventsc.wxNotifyEvent_Veto,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxNotifyEvent instance at %s>" % (self.this,)
+class wxNotifyEvent(wxNotifyEventPtr):
+ def __init__(self,this):
+ self.this = this
+
+
+
+
+class wxPyEventPtr(wxEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self,eventsc=eventsc):
if self.thisown == 1 :
eventsc.delete_wxPyEvent(self)
- def SetUserData(self, *_args, **_kwargs):
- val = apply(eventsc.wxPyEvent_SetUserData,(self,) + _args, _kwargs)
+ def SetPyData(self, *_args, **_kwargs):
+ val = apply(eventsc.wxPyEvent_SetPyData,(self,) + _args, _kwargs)
return val
- def GetUserData(self, *_args, **_kwargs):
- val = apply(eventsc.wxPyEvent_GetUserData,(self,) + _args, _kwargs)
+ def GetPyData(self, *_args, **_kwargs):
+ val = apply(eventsc.wxPyEvent_GetPyData,(self,) + _args, _kwargs)
return val
def __repr__(self):
return "<C wxPyEvent instance at %s>" % (self.this,)
-class wxNotifyEventPtr(wxCommandEventPtr):
+class wxPyCommandEventPtr(wxCommandEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
- def IsAllowed(self, *_args, **_kwargs):
- val = apply(eventsc.wxNotifyEvent_IsAllowed,(self,) + _args, _kwargs)
+ def __del__(self,eventsc=eventsc):
+ if self.thisown == 1 :
+ eventsc.delete_wxPyCommandEvent(self)
+ def SetPyData(self, *_args, **_kwargs):
+ val = apply(eventsc.wxPyCommandEvent_SetPyData,(self,) + _args, _kwargs)
return val
- def Veto(self, *_args, **_kwargs):
- val = apply(eventsc.wxNotifyEvent_Veto,(self,) + _args, _kwargs)
+ def GetPyData(self, *_args, **_kwargs):
+ val = apply(eventsc.wxPyCommandEvent_GetPyData,(self,) + _args, _kwargs)
return val
def __repr__(self):
- return "<C wxNotifyEvent instance at %s>" % (self.this,)
-class wxNotifyEvent(wxNotifyEventPtr):
- def __init__(self,this):
- self.this = this
+ return "<C wxPyCommandEvent instance at %s>" % (self.this,)
+class wxPyCommandEvent(wxPyCommandEventPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(eventsc.new_wxPyCommandEvent,_args,_kwargs)
+ self.thisown = 1
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __cplusplus
extern "C" {
char * _arg6 = (char *) "frame";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","title","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxFrame. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxFrame. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxFrame *)new_wxFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
char * _arg6 = (char *) "frame";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","title","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxMiniFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxMiniFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMiniFrame. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMiniFrame. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxMiniFrame *)new_wxMiniFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxCheckListBox","_class_wxCheckListBox",0},
{ "_wxRect","_class_wxRect",0},
{ "_wxToolBarTool","_class_wxToolBarTool",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticBitmap","_wxStaticBitmap",0},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_wxSize","_class_wxSize",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_wxControl",0},
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
// Alternate 'constructor'
wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
wxScreenDC * _arg0;
wxRect * _arg1 = (wxRect *) NULL;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|O:wxScreenDC_StartDrawingOnTopRect",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|O:wxScreenDC_StartDrawingOnTopRect",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxScreenDC_StartDrawingOnTopRect. Expected _wxRect_p.");
+ if (_obj1)
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxScreenDC_StartDrawingOnTopRect(_arg0,_arg1);
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
wxImage* wxNullImage() {
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __cplusplus
extern "C" {
char * _arg6 = (char *) "frame";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","title","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxMDIParentFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxMDIParentFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIParentFrame. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIParentFrame. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
char * _arg6 = (char *) "frame";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","title","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxMDIChildFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxMDIChildFrame",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIChildFrame. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIChildFrame. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxCheckListBox","_class_wxCheckListBox",0},
{ "_wxRect","_class_wxRect",0},
{ "_wxToolBarTool","_class_wxToolBarTool",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticBitmap","_wxStaticBitmap",0},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_wxSize","_class_wxSize",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_wxControl",0},
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
char* wxGetResource(char *section, char *entry, char *file = NULL) {
PyObject * _obj1 = 0;
PyObject * _obj2 = 0;
PyObject * _argo6 = 0;
- PyObject * _argo7 = 0;
+ wxPoint temp;
+ PyObject * _obj7 = 0;
char *_kwnames[] = { "message","prompt","caption","value","min","max","parent","pos", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOl|llOO:wxGetNumberFromUser",_kwnames,&_obj0,&_obj1,&_obj2,&_arg3,&_arg4,&_arg5,&_argo6,&_argo7))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOl|llOO:wxGetNumberFromUser",_kwnames,&_obj0,&_obj1,&_obj2,&_arg3,&_arg4,&_arg5,&_argo6,&_obj7))
return NULL;
{
if (!PyString_Check(_obj0)) {
return NULL;
}
}
- if (_argo7) {
- if (_argo7 == Py_None) { _arg7 = NULL; }
- else if (SWIG_GetPtrObj(_argo7,(void **) &_arg7,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 8 of wxGetNumberFromUser. Expected _wxPoint_p.");
+ if (_obj7)
+{
+ _arg7 = &temp;
+ if (! wxPoint_helper(_obj7, &_arg7))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxGetNumberFromUser(*_arg0,*_arg1,*_arg2,_arg3,_arg4,_arg5,_arg6,*_arg7);
long _result;
wxSize * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","x", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_x_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_x_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_x_set. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_x_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_x_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_x_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_x_get. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_x_get(_arg0);
long _result;
wxSize * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","y", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_y_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_y_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_y_set. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_y_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_y_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_y_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_y_get. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_y_get(_arg0);
static PyObject *_wrap_delete_wxSize(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxSize",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxSize",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxSize. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
delete_wxSize(_arg0);
wxSize * _arg0;
long _arg1;
long _arg2;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","w","h", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oll:wxSize_Set",_kwnames,&_argo0,&_arg1,&_arg2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oll:wxSize_Set",_kwnames,&_obj0,&_arg1,&_arg2))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_Set. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSize_Set(_arg0,_arg1,_arg2);
PyObject * _resultobj;
long _result;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetX",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetX",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_GetX. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_GetX(_arg0);
PyObject * _resultobj;
long _result;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetY",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetY",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_GetY. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_GetY(_arg0);
PyObject * _resultobj;
long _result;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetWidth",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetWidth",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_GetWidth. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_GetWidth(_arg0);
PyObject * _resultobj;
long _result;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetHeight",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_GetHeight",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_GetHeight. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_GetHeight(_arg0);
PyObject * _resultobj;
wxSize * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","w", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_SetWidth",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_SetWidth",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_SetWidth. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSize_SetWidth(_arg0,_arg1);
PyObject * _resultobj;
wxSize * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","h", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_SetHeight",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxSize_SetHeight",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_SetHeight. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSize_SetHeight(_arg0,_arg1);
PyObject * _resultobj;
PyObject * _result;
wxSize * _arg0;
- PyObject * _argo0 = 0;
+ wxSize temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_asTuple",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSize_asTuple",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_asTuple. Expected _wxSize_p.");
+{
+ _arg0 = &temp;
+ if (! wxSize_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (PyObject *)wxSize_asTuple(_arg0);
double _result;
wxRealPoint * _arg0;
double _arg1;
- PyObject * _argo0 = 0;
+ wxRealPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","x", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Od:wxRealPoint_x_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Od:wxRealPoint_x_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRealPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRealPoint_x_set. Expected _wxRealPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxRealPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (double )wxRealPoint_x_set(_arg0,_arg1);
PyObject * _resultobj;
double _result;
wxRealPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxRealPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRealPoint_x_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRealPoint_x_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRealPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRealPoint_x_get. Expected _wxRealPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxRealPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (double )wxRealPoint_x_get(_arg0);
double _result;
wxRealPoint * _arg0;
double _arg1;
- PyObject * _argo0 = 0;
+ wxRealPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","y", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Od:wxRealPoint_y_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Od:wxRealPoint_y_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRealPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRealPoint_y_set. Expected _wxRealPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxRealPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (double )wxRealPoint_y_set(_arg0,_arg1);
PyObject * _resultobj;
double _result;
wxRealPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxRealPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRealPoint_y_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRealPoint_y_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRealPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRealPoint_y_get. Expected _wxRealPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxRealPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (double )wxRealPoint_y_get(_arg0);
static PyObject *_wrap_delete_wxRealPoint(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxRealPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxRealPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxRealPoint",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxRealPoint",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRealPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxRealPoint. Expected _wxRealPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxRealPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
delete_wxRealPoint(_arg0);
wxRealPoint * _arg0;
double _arg1;
double _arg2;
- PyObject * _argo0 = 0;
+ wxRealPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","x","y", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Odd:wxRealPoint_Set",_kwnames,&_argo0,&_arg1,&_arg2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Odd:wxRealPoint_Set",_kwnames,&_obj0,&_arg1,&_arg2))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRealPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRealPoint_Set. Expected _wxRealPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxRealPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxRealPoint_Set(_arg0,_arg1,_arg2);
PyObject * _resultobj;
PyObject * _result;
wxRealPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxRealPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRealPoint_asTuple",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRealPoint_asTuple",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRealPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRealPoint_asTuple. Expected _wxRealPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxRealPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (PyObject *)wxRealPoint_asTuple(_arg0);
long _result;
wxPoint * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","x", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxPoint_x_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxPoint_x_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPoint_x_set. Expected _wxPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxPoint_x_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPoint_x_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPoint_x_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPoint_x_get. Expected _wxPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxPoint_x_get(_arg0);
long _result;
wxPoint * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","y", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxPoint_y_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxPoint_y_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPoint_y_set. Expected _wxPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxPoint_y_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPoint_y_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPoint_y_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPoint_y_get. Expected _wxPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxPoint_y_get(_arg0);
static PyObject *_wrap_delete_wxPoint(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxPoint",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxPoint",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxPoint. Expected _wxPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
delete_wxPoint(_arg0);
wxPoint * _arg0;
long _arg1;
long _arg2;
- PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","x","y", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oll:wxPoint_Set",_kwnames,&_argo0,&_arg1,&_arg2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oll:wxPoint_Set",_kwnames,&_obj0,&_arg1,&_arg2))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPoint_Set. Expected _wxPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPoint_Set(_arg0,_arg1,_arg2);
PyObject * _resultobj;
PyObject * _result;
wxPoint * _arg0;
- PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPoint_asTuple",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPoint_asTuple",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPoint_asTuple. Expected _wxPoint_p.");
+{
+ _arg0 = &temp;
+ if (! wxPoint_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (PyObject *)wxPoint_asTuple(_arg0);
static PyObject *_wrap_delete_wxRect(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxRect",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxRect",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxRect. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
delete_wxRect(_arg0);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetX",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetX",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetX. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetX(_arg0);
PyObject * _resultobj;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","X", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetX",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetX",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_SetX. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxRect_SetX(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetY",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetY",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetY. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetY(_arg0);
PyObject * _resultobj;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","Y", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetY",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetY",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_SetY. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxRect_SetY(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetWidth",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetWidth",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetWidth. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetWidth(_arg0);
PyObject * _resultobj;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","w", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetWidth",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetWidth",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_SetWidth. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxRect_SetWidth(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetHeight",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetHeight",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetHeight. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetHeight(_arg0);
PyObject * _resultobj;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","h", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetHeight",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_SetHeight",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_SetHeight. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxRect_SetHeight(_arg0,_arg1);
PyObject * _resultobj;
wxPoint * _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetPosition",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetPosition",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetPosition. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxPoint (wxRect_GetPosition(_arg0));
PyObject * _resultobj;
wxSize * _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetSize",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetSize",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetSize. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxSize (wxRect_GetSize(_arg0));
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetLeft",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetLeft",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetLeft. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetLeft(_arg0);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetTop",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetTop",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetTop. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetTop(_arg0);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetBottom",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetBottom",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetBottom. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetBottom(_arg0);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetRight",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_GetRight",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_GetRight. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_GetRight(_arg0);
long _result;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","x", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_x_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_x_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_x_set. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_x_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_x_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_x_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_x_get. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_x_get(_arg0);
long _result;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","y", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_y_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_y_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_y_set. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_y_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_y_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_y_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_y_get. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_y_get(_arg0);
long _result;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","width", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_width_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_width_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_width_set. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_width_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_width_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_width_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_width_get. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_width_get(_arg0);
long _result;
wxRect * _arg0;
long _arg1;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self","height", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_height_set",_kwnames,&_argo0,&_arg1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxRect_height_set",_kwnames,&_obj0,&_arg1))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_height_set. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_height_set(_arg0,_arg1);
PyObject * _resultobj;
long _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_height_get",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_height_get",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_height_get. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxRect_height_get(_arg0);
PyObject * _resultobj;
PyObject * _result;
wxRect * _arg0;
- PyObject * _argo0 = 0;
+ wxRect temp;
+ PyObject * _obj0 = 0;
char *_kwnames[] = { "self", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_asTuple",_kwnames,&_argo0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRect_asTuple",_kwnames,&_obj0))
return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRect_asTuple. Expected _wxRect_p.");
+{
+ _arg0 = &temp;
+ if (! wxRect_helper(_obj0, &_arg0))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (PyObject *)wxRect_asTuple(_arg0);
wxRegion * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_ContainsPoint",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_ContainsPoint",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxRegion_ContainsPoint. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxRegionContain )wxRegion_ContainsPoint(_arg0,*_arg1);
wxRegion * _arg0;
wxRect * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_ContainsRect",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_ContainsRect",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxRegion_ContainsRect. Expected _wxRect_p.");
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxRegionContain )wxRegion_ContainsRect(_arg0,*_arg1);
wxRegion * _arg0;
wxRect * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Intersect",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Intersect",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxRegion_Intersect. Expected _wxRect_p.");
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxRegion_Intersect(_arg0,*_arg1);
wxRegion * _arg0;
wxRect * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Subtract",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Subtract",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxRegion_Subtract. Expected _wxRect_p.");
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxRegion_Subtract(_arg0,*_arg1);
wxRegion * _arg0;
wxRect * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Union",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Union",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxRegion_Union. Expected _wxRect_p.");
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxRegion_Union(_arg0,*_arg1);
wxRegion * _arg0;
wxRect * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Xor",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRegion_Xor",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxRegion_Xor. Expected _wxRect_p.");
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxRegion_Xor(_arg0,*_arg1);
return _resultobj;
}
+#define delete_wxAcceleratorEntry(_swigobj) (delete _swigobj)
+static PyObject *_wrap_delete_wxAcceleratorEntry(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxAcceleratorEntry * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxAcceleratorEntry",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxAcceleratorEntry_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxAcceleratorEntry. Expected _wxAcceleratorEntry_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ delete_wxAcceleratorEntry(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
#define wxAcceleratorEntry_Set(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->Set(_swigarg0,_swigarg1,_swigarg2))
static PyObject *_wrap_wxAcceleratorEntry_Set(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define delete_wxAcceleratorTable(_swigobj) (delete _swigobj)
+static PyObject *_wrap_delete_wxAcceleratorTable(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxAcceleratorTable * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxAcceleratorTable",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxAcceleratorTable_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxAcceleratorTable. Expected _wxAcceleratorTable_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ delete_wxAcceleratorTable(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
static PyMethodDef misccMethods[] = {
+ { "delete_wxAcceleratorTable", (PyCFunction) _wrap_delete_wxAcceleratorTable, METH_VARARGS | METH_KEYWORDS },
{ "new_wxAcceleratorTable", (PyCFunction) _wrap_new_wxAcceleratorTable, METH_VARARGS | METH_KEYWORDS },
{ "wxAcceleratorEntry_GetCommand", (PyCFunction) _wrap_wxAcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS },
{ "wxAcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_wxAcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS },
{ "wxAcceleratorEntry_GetFlags", (PyCFunction) _wrap_wxAcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS },
{ "wxAcceleratorEntry_Set", (PyCFunction) _wrap_wxAcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS },
+ { "delete_wxAcceleratorEntry", (PyCFunction) _wrap_delete_wxAcceleratorEntry, METH_VARARGS | METH_KEYWORDS },
{ "new_wxAcceleratorEntry", (PyCFunction) _wrap_new_wxAcceleratorEntry, METH_VARARGS | METH_KEYWORDS },
{ "wxRegionIterator_Next", (PyCFunction) _wrap_wxRegionIterator_Next, METH_VARARGS | METH_KEYWORDS },
{ "wxRegionIterator_Reset", (PyCFunction) _wrap_wxRegionIterator_Reset, METH_VARARGS | METH_KEYWORDS },
def __init__(self,this):
self.this = this
self.thisown = 0
+ def __del__(self,miscc=miscc):
+ if self.thisown == 1 :
+ miscc.delete_wxAcceleratorEntry(self)
def Set(self, *_args, **_kwargs):
val = apply(miscc.wxAcceleratorEntry_Set,(self,) + _args, _kwargs)
return val
def __init__(self,this):
self.this = this
self.thisown = 0
+ def __del__(self,miscc=miscc):
+ if self.thisown == 1 :
+ miscc.delete_wxAcceleratorTable(self)
def __repr__(self):
return "<C wxAcceleratorTable instance at %s>" % (self.this,)
class wxAcceleratorTable(wxAcceleratorTablePtr):
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
void wxToolTip_Enable(bool flag) {
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_wxRect","_class_wxRect",0},
{ "_wxPoint","_class_wxPoint",0},
{ "_wxBitmap","_class_wxBitmap",0},
{ "_wxPyTimer","_class_wxPyTimer",0},
{ "_wxWindowDC","_class_wxWindowDC",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_EBool","_wxPrintQuality",0},
{ "_EBool","_signed_int",0},
{ "_EBool","_int",0},
{ "_unsigned_short","_short",0},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_class_wxPoint","_wxPoint",0},
{ "_wxRealPoint","_class_wxRealPoint",0},
{ "_wxRegionIterator","_class_wxRegionIterator",0},
{ "_class_wxPrinterDC","_wxPrinterDC",0},
{ "_class_wxPaintDC","_wxPaintDC",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_class_wxIcon","_wxIcon",0},
{ "_class_wxColour","_wxColour",0},
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
class wxPyPrintout : public wxPrintout {
wxPrintData * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","sz", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPrintData_SetPaperSize",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPrintData_SetPaperSize",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPrintData_SetPaperSize. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPrintData_SetPaperSize(_arg0,*_arg1);
wxPageSetupDialogData * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMarginTopLeft",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMarginTopLeft",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMarginTopLeft. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPageSetupDialogData_SetMarginTopLeft(_arg0,*_arg1);
wxPageSetupDialogData * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMarginBottomRight",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMarginBottomRight",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMarginBottomRight. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPageSetupDialogData_SetMarginBottomRight(_arg0,*_arg1);
wxPageSetupDialogData * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMinMarginTopLeft",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMinMarginTopLeft",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMinMarginTopLeft. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPageSetupDialogData_SetMinMarginTopLeft(_arg0,*_arg1);
wxPageSetupDialogData * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMinMarginBottomRight",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetMinMarginBottomRight",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetMinMarginBottomRight. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPageSetupDialogData_SetMinMarginBottomRight(_arg0,*_arg1);
wxPageSetupDialogData * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","size", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetPaperSize",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPageSetupDialogData_SetPaperSize",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPageSetupDialogData_SetPaperSize. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPageSetupDialogData_SetPaperSize(_arg0,*_arg1);
PyObject * _argo0 = 0;
PyObject * _argo1 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "preview","parent","title","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|OOls:new_wxPreviewFrame",_kwnames,&_argo0,&_argo1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO|OOls:new_wxPreviewFrame",_kwnames,&_argo0,&_argo1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxPreviewFrame. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxPreviewFrame. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxPreviewFrame *)new_wxPreviewFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxCheckListBox","_class_wxCheckListBox",0},
{ "_wxRect","_class_wxRect",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
{ "_wxMessageDialog","_class_wxMessageDialog",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_wxTextEntryDialog","_class_wxTextEntryDialog",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_wxPrintDialogData","_class_wxPrintDialogData",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxPrintPreview","_wxPrintPreview",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_wxControl",0},
--- /dev/null
+/*
+ * FILE : msw/sizers.cpp
+ *
+ * This file was automatically generated by :
+ * Simplified Wrapper and Interface Generator (SWIG)
+ * Version 1.1 (Build 810)
+ *
+ * Portions Copyright (c) 1995-1998
+ * The University of Utah and The Regents of the University of California.
+ * Permission is granted to distribute this file in any manner provided
+ * this notice remains intact.
+ *
+ * Do not make changes to this file--changes will be lost!
+ *
+ */
+
+
+#define SWIGCODE
+/* Implementation : PYTHON */
+
+#define SWIGPYTHON
+#include <string.h>
+#include <stdlib.h>
+/* Definitions for Windows/Unix exporting */
+#if defined(__WIN32__)
+# if defined(_MSC_VER)
+# define SWIGEXPORT(a) __declspec(dllexport) a
+# else
+# if defined(__BORLANDC__)
+# define SWIGEXPORT(a) a _export
+# else
+# define SWIGEXPORT(a) a
+# endif
+# endif
+#else
+# define SWIGEXPORT(a) a
+#endif
+
+#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 char *SWIG_GetPtrObj(PyObject *, void **, char *);
+extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
+extern PyObject *SWIG_newvarlink(void);
+#ifdef __cplusplus
+}
+#endif
+#define SWIG_init initsizersc
+
+#define SWIG_name "sizersc"
+
+#include "helpers.h"
+
+static PyObject* l_output_helper(PyObject* target, PyObject* o) {
+ PyObject* o2;
+ PyObject* o3;
+ if (!target) {
+ target = o;
+ } else if (target == Py_None) {
+ Py_DECREF(Py_None);
+ target = o;
+ } else {
+ if (!PyList_Check(target)) {
+ o2 = target;
+ target = PyList_New(0);
+ PyList_Append(target, o2);
+ Py_XDECREF(o2);
+ }
+ PyList_Append(target,o);
+ Py_XDECREF(o);
+ }
+ return target;
+}
+
+static PyObject* t_output_helper(PyObject* target, PyObject* o) {
+ PyObject* o2;
+ PyObject* o3;
+
+ if (!target) {
+ target = o;
+ } else if (target == Py_None) {
+ Py_DECREF(Py_None);
+ target = o;
+ } else {
+ if (!PyTuple_Check(target)) {
+ o2 = target;
+ target = PyTuple_New(1);
+ PyTuple_SetItem(target, 0, o2);
+ }
+ o3 = PyTuple_New(1);
+ PyTuple_SetItem(o3, 0, o);
+
+ o2 = target;
+ target = PySequence_Concat(o2, o3);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ }
+ return target;
+}
+
+static char* wxStringErrorMsg = "string type is required for parameter";
+
+class wxPyUserData : public wxObject {
+public:
+ wxPyUserData(PyObject* obj) { m_obj = obj; Py_INCREF(m_obj); }
+ ~wxPyUserData() {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_obj);
+ wxPySaveThread(doSave);
+ }
+ PyObject* m_obj;
+};
+
+class wxPySizer : public wxSizer {
+ DECLARE_DYNAMIC_CLASS(wxPySizer);
+public:
+ wxPySizer() : wxSizer() {};
+
+ DEC_PYCALLBACK___pure(RecalcSizes);
+ DEC_PYCALLBACK_wxSize__pure(CalcMin);
+ PYPRIVATE;
+};
+
+
+IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
+IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
+
+IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define wxSizerItem_GetSize(_swigobj) (_swigobj->GetSize())
+static PyObject *_wrap_wxSizerItem_GetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSize * _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_GetSize",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_GetSize. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxSize (wxSizerItem_GetSize(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxSizerItem_CalcMin(_swigobj) (_swigobj->CalcMin())
+static PyObject *_wrap_wxSizerItem_CalcMin(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSize * _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_CalcMin",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_CalcMin. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxSize (wxSizerItem_CalcMin(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxSizerItem_SetDimension(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetDimension(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxSizerItem_SetDimension(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizerItem * _arg0;
+ wxPoint * _arg1;
+ wxSize * _arg2;
+ PyObject * _argo0 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
+ wxSize temp0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","pos","size", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxSizerItem_SetDimension",_kwnames,&_argo0,&_obj1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_SetDimension. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
+ return NULL;
+}
+{
+ _arg2 = &temp0;
+ if (! wxSize_helper(_obj2, &_arg2))
+ return NULL;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizerItem_SetDimension(_arg0,*_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxSizerItem_IsWindow(_swigobj) (_swigobj->IsWindow())
+static PyObject *_wrap_wxSizerItem_IsWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_IsWindow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_IsWindow. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxSizerItem_IsWindow(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizerItem_IsSizer(_swigobj) (_swigobj->IsSizer())
+static PyObject *_wrap_wxSizerItem_IsSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_IsSizer",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_IsSizer. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxSizerItem_IsSizer(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizerItem_IsSpacer(_swigobj) (_swigobj->IsSpacer())
+static PyObject *_wrap_wxSizerItem_IsSpacer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_IsSpacer",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_IsSpacer. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxSizerItem_IsSpacer(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizerItem_GetWindow(_swigobj) (_swigobj->GetWindow())
+static PyObject *_wrap_wxSizerItem_GetWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_GetWindow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_GetWindow. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxWindow *)wxSizerItem_GetWindow(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxSizerItem_GetSizer(_swigobj) (_swigobj->GetSizer())
+static PyObject *_wrap_wxSizerItem_GetSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_GetSizer",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_GetSizer. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxSizer *)wxSizerItem_GetSizer(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxSizer_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxSizerItem_GetOption(_swigobj) (_swigobj->GetOption())
+static PyObject *_wrap_wxSizerItem_GetOption(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_GetOption",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_GetOption. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxSizerItem_GetOption(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizerItem_GetFlag(_swigobj) (_swigobj->GetFlag())
+static PyObject *_wrap_wxSizerItem_GetFlag(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_GetFlag",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_GetFlag. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxSizerItem_GetFlag(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizerItem_GetBorder(_swigobj) (_swigobj->GetBorder())
+static PyObject *_wrap_wxSizerItem_GetBorder(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_GetBorder",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_GetBorder. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxSizerItem_GetBorder(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+static PyObject * wxSizerItem_GetUserData(wxSizerItem *self) {
+ wxPyUserData* data = (wxPyUserData*)self->GetUserData();
+ if (data) {
+ Py_INCREF(data->m_obj);
+ return data->m_obj;
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ }
+static PyObject *_wrap_wxSizerItem_GetUserData(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ PyObject * _result;
+ wxSizerItem * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizerItem_GetUserData",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizerItem_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizerItem_GetUserData. Expected _wxSizerItem_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (PyObject *)wxSizerItem_GetUserData(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = _result;
+}
+ return _resultobj;
+}
+
+static void wxSizer_Destroy(wxSizer *self) { delete self; }
+static PyObject *_wrap_wxSizer_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizer_Destroy",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_Destroy. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_Destroy(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void wxSizer_AddWindow(wxSizer *self,wxWindow * window,int option,int flag,int border,PyObject * userData) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Add(window, option, flag, border, data);
+ }
+static PyObject *_wrap_wxSizer_AddWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ wxWindow * _arg1;
+ int _arg2 = (int ) 0;
+ int _arg3 = (int ) 0;
+ int _arg4 = (int ) 0;
+ PyObject * _arg5 = (PyObject *) NULL;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj5 = 0;
+ char *_kwnames[] = { "self","window","option","flag","border","userData", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|iiiO:wxSizer_AddWindow",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3,&_arg4,&_obj5))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_AddWindow. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_AddWindow. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+ if (_obj5)
+{
+ _arg5 = _obj5;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_AddWindow(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void wxSizer_AddSizer(wxSizer *self,wxSizer * sizer,int option,int flag,int border,PyObject * userData) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Add(sizer, option, flag, border, data);
+ }
+static PyObject *_wrap_wxSizer_AddSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ wxSizer * _arg1;
+ int _arg2 = (int ) 0;
+ int _arg3 = (int ) 0;
+ int _arg4 = (int ) 0;
+ PyObject * _arg5 = (PyObject *) NULL;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj5 = 0;
+ char *_kwnames[] = { "self","sizer","option","flag","border","userData", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|iiiO:wxSizer_AddSizer",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3,&_arg4,&_obj5))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_AddSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_AddSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_obj5)
+{
+ _arg5 = _obj5;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_AddSizer(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void wxSizer_AddSpacer(wxSizer *self,int width,int height,int option,int flag,int border,PyObject * userData) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Add(width, height, option, flag, border, data);
+ }
+static PyObject *_wrap_wxSizer_AddSpacer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ int _arg1;
+ int _arg2;
+ int _arg3 = (int ) 0;
+ int _arg4 = (int ) 0;
+ int _arg5 = (int ) 0;
+ PyObject * _arg6 = (PyObject *) NULL;
+ PyObject * _argo0 = 0;
+ PyObject * _obj6 = 0;
+ char *_kwnames[] = { "self","width","height","option","flag","border","userData", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|iiiO:wxSizer_AddSpacer",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_obj6))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_AddSpacer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_obj6)
+{
+ _arg6 = _obj6;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_AddSpacer(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void wxSizer_PrependWindow(wxSizer *self,wxWindow * window,int option,int flag,int border,PyObject * userData) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Prepend(window, option, flag, border, data);
+ }
+static PyObject *_wrap_wxSizer_PrependWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ wxWindow * _arg1;
+ int _arg2 = (int ) 0;
+ int _arg3 = (int ) 0;
+ int _arg4 = (int ) 0;
+ PyObject * _arg5 = (PyObject *) NULL;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj5 = 0;
+ char *_kwnames[] = { "self","window","option","flag","border","userData", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|iiiO:wxSizer_PrependWindow",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3,&_arg4,&_obj5))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_PrependWindow. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_PrependWindow. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+ if (_obj5)
+{
+ _arg5 = _obj5;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_PrependWindow(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void wxSizer_PrependSizer(wxSizer *self,wxSizer * sizer,int option,int flag,int border,PyObject * userData) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Prepend(sizer, option, flag, border, data);
+ }
+static PyObject *_wrap_wxSizer_PrependSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ wxSizer * _arg1;
+ int _arg2 = (int ) 0;
+ int _arg3 = (int ) 0;
+ int _arg4 = (int ) 0;
+ PyObject * _arg5 = (PyObject *) NULL;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ PyObject * _obj5 = 0;
+ char *_kwnames[] = { "self","sizer","option","flag","border","userData", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|iiiO:wxSizer_PrependSizer",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3,&_arg4,&_obj5))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_PrependSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_PrependSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_obj5)
+{
+ _arg5 = _obj5;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_PrependSizer(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void wxSizer_PrependSpacer(wxSizer *self,int width,int height,int option,int flag,int border,PyObject * userData) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Prepend(width, height, option, flag, border, data);
+ }
+static PyObject *_wrap_wxSizer_PrependSpacer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ int _arg1;
+ int _arg2;
+ int _arg3 = (int ) 0;
+ int _arg4 = (int ) 0;
+ int _arg5 = (int ) 0;
+ PyObject * _arg6 = (PyObject *) NULL;
+ PyObject * _argo0 = 0;
+ PyObject * _obj6 = 0;
+ char *_kwnames[] = { "self","width","height","option","flag","border","userData", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|iiiO:wxSizer_PrependSpacer",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_obj6))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_PrependSpacer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_obj6)
+{
+ _arg6 = _obj6;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_PrependSpacer(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxSizer_RemoveWindow(_swigobj,_swigarg0) (_swigobj->Remove(_swigarg0))
+static PyObject *_wrap_wxSizer_RemoveWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSizer * _arg0;
+ wxWindow * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","window", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSizer_RemoveWindow",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_RemoveWindow. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_RemoveWindow. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxSizer_RemoveWindow(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizer_RemoveSizer(_swigobj,_swigarg0) (_swigobj->Remove(_swigarg0))
+static PyObject *_wrap_wxSizer_RemoveSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSizer * _arg0;
+ wxSizer * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","sizer", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSizer_RemoveSizer",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_RemoveSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_RemoveSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxSizer_RemoveSizer(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizer_RemovePos(_swigobj,_swigarg0) (_swigobj->Remove(_swigarg0))
+static PyObject *_wrap_wxSizer_RemovePos(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxSizer * _arg0;
+ int _arg1;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","pos", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxSizer_RemovePos",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_RemovePos. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxSizer_RemovePos(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxSizer_SetDimension(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3) (_swigobj->SetDimension(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
+static PyObject *_wrap_wxSizer_SetDimension(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ int _arg1;
+ int _arg2;
+ int _arg3;
+ int _arg4;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self","x","y","width","height", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii:wxSizer_SetDimension",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_SetDimension. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_SetDimension(_arg0,_arg1,_arg2,_arg3,_arg4);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxSizer_GetSize(_swigobj) (_swigobj->GetSize())
+static PyObject *_wrap_wxSizer_GetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSize * _result;
+ wxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizer_GetSize",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_GetSize. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxSize (wxSizer_GetSize(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxSizer_GetPosition(_swigobj) (_swigobj->GetPosition())
+static PyObject *_wrap_wxSizer_GetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxPoint * _result;
+ wxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizer_GetPosition",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_GetPosition. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxPoint (wxSizer_GetPosition(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxSizer_GetMinSize(_swigobj) (_swigobj->GetMinSize())
+static PyObject *_wrap_wxSizer_GetMinSize(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSize * _result;
+ wxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizer_GetMinSize",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_GetMinSize. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = new wxSize (wxSizer_GetMinSize(_arg0));
+
+ wxPy_END_ALLOW_THREADS;
+} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ return _resultobj;
+}
+
+#define wxSizer_Layout(_swigobj) (_swigobj->Layout())
+static PyObject *_wrap_wxSizer_Layout(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizer_Layout",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_Layout. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_Layout(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxSizer_Fit(_swigobj,_swigarg0) (_swigobj->Fit(_swigarg0))
+static PyObject *_wrap_wxSizer_Fit(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ wxWindow * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","window", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSizer_Fit",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_Fit. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_Fit. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_Fit(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxSizer_SetSizeHints(_swigobj,_swigarg0) (_swigobj->SetSizeHints(_swigarg0))
+static PyObject *_wrap_wxSizer_SetSizeHints(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxSizer * _arg0;
+ wxWindow * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","window", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSizer_SetSizeHints",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_SetSizeHints. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSizer_SetSizeHints. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxSizer_SetSizeHints(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static PyObject * wxSizer_GetChildren(wxSizer *self) {
+ wxList& list = self->GetChildren();
+ return wxPy_ConvertList(&list, "wxSizerItem");
+ }
+static PyObject *_wrap_wxSizer_GetChildren(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ PyObject * _result;
+ wxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxSizer_GetChildren",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSizer_GetChildren. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (PyObject *)wxSizer_GetChildren(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+}{
+ _resultobj = _result;
+}
+ return _resultobj;
+}
+
+static void *SwigwxPySizerTowxSizer(void *ptr) {
+ wxPySizer *src;
+ wxSizer *dest;
+ src = (wxPySizer *) ptr;
+ dest = (wxSizer *) src;
+ return (void *) dest;
+}
+
+#define new_wxPySizer() (new wxPySizer())
+static PyObject *_wrap_new_wxPySizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxPySizer * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPySizer",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxPySizer *)new_wxPySizer();
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxPySizer_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxPySizer__setSelf(_swigobj,_swigarg0) (_swigobj->_setSelf(_swigarg0))
+static PyObject *_wrap_wxPySizer__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxPySizer * _arg0;
+ PyObject * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPySizer__setSelf",_kwnames,&_argo0,&_obj1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPySizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPySizer__setSelf. Expected _wxPySizer_p.");
+ return NULL;
+ }
+ }
+{
+ _arg1 = _obj1;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxPySizer__setSelf(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void *SwigwxBoxSizerTowxSizer(void *ptr) {
+ wxBoxSizer *src;
+ wxSizer *dest;
+ src = (wxBoxSizer *) ptr;
+ dest = (wxSizer *) src;
+ return (void *) dest;
+}
+
+#define new_wxBoxSizer(_swigarg0) (new wxBoxSizer(_swigarg0))
+static PyObject *_wrap_new_wxBoxSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxBoxSizer * _result;
+ int _arg0 = (int ) wxHORIZONTAL;
+ char *_kwnames[] = { "orient", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|i:new_wxBoxSizer",_kwnames,&_arg0))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxBoxSizer *)new_wxBoxSizer(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxBoxSizer_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxBoxSizer_GetOrientation(_swigobj) (_swigobj->GetOrientation())
+static PyObject *_wrap_wxBoxSizer_GetOrientation(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _result;
+ wxBoxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxBoxSizer_GetOrientation",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxBoxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxBoxSizer_GetOrientation. Expected _wxBoxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (int )wxBoxSizer_GetOrientation(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+static void *SwigwxStaticBoxSizerTowxBoxSizer(void *ptr) {
+ wxStaticBoxSizer *src;
+ wxBoxSizer *dest;
+ src = (wxStaticBoxSizer *) ptr;
+ dest = (wxBoxSizer *) src;
+ return (void *) dest;
+}
+
+static void *SwigwxStaticBoxSizerTowxSizer(void *ptr) {
+ wxStaticBoxSizer *src;
+ wxSizer *dest;
+ src = (wxStaticBoxSizer *) ptr;
+ dest = (wxSizer *) src;
+ return (void *) dest;
+}
+
+#define new_wxStaticBoxSizer(_swigarg0,_swigarg1) (new wxStaticBoxSizer(_swigarg0,_swigarg1))
+static PyObject *_wrap_new_wxStaticBoxSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxStaticBoxSizer * _result;
+ wxStaticBox * _arg0;
+ int _arg1 = (int ) wxHORIZONTAL;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "box","orient", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:new_wxStaticBoxSizer",_kwnames,&_argo0,&_arg1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxStaticBox_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxStaticBoxSizer. Expected _wxStaticBox_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxStaticBoxSizer *)new_wxStaticBoxSizer(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticBoxSizer_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxStaticBoxSizer_GetStaticBox(_swigobj) (_swigobj->GetStaticBox())
+static PyObject *_wrap_wxStaticBoxSizer_GetStaticBox(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxStaticBox * _result;
+ wxStaticBoxSizer * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxStaticBoxSizer_GetStaticBox",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxStaticBoxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxStaticBoxSizer_GetStaticBox. Expected _wxStaticBoxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxStaticBox *)wxStaticBoxSizer_GetStaticBox(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxStaticBox_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+static PyMethodDef sizerscMethods[] = {
+ { "wxStaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_wxStaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxStaticBoxSizer", (PyCFunction) _wrap_new_wxStaticBoxSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxBoxSizer_GetOrientation", (PyCFunction) _wrap_wxBoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxBoxSizer", (PyCFunction) _wrap_new_wxBoxSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxPySizer__setSelf", (PyCFunction) _wrap_wxPySizer__setSelf, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxPySizer", (PyCFunction) _wrap_new_wxPySizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_GetChildren", (PyCFunction) _wrap_wxSizer_GetChildren, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_SetSizeHints", (PyCFunction) _wrap_wxSizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_Fit", (PyCFunction) _wrap_wxSizer_Fit, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_Layout", (PyCFunction) _wrap_wxSizer_Layout, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_GetMinSize", (PyCFunction) _wrap_wxSizer_GetMinSize, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_GetPosition", (PyCFunction) _wrap_wxSizer_GetPosition, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_GetSize", (PyCFunction) _wrap_wxSizer_GetSize, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_SetDimension", (PyCFunction) _wrap_wxSizer_SetDimension, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_RemovePos", (PyCFunction) _wrap_wxSizer_RemovePos, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_RemoveSizer", (PyCFunction) _wrap_wxSizer_RemoveSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_RemoveWindow", (PyCFunction) _wrap_wxSizer_RemoveWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_PrependSpacer", (PyCFunction) _wrap_wxSizer_PrependSpacer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_PrependSizer", (PyCFunction) _wrap_wxSizer_PrependSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_PrependWindow", (PyCFunction) _wrap_wxSizer_PrependWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_AddSpacer", (PyCFunction) _wrap_wxSizer_AddSpacer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_AddSizer", (PyCFunction) _wrap_wxSizer_AddSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_AddWindow", (PyCFunction) _wrap_wxSizer_AddWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizer_Destroy", (PyCFunction) _wrap_wxSizer_Destroy, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_GetUserData", (PyCFunction) _wrap_wxSizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_GetBorder", (PyCFunction) _wrap_wxSizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_GetFlag", (PyCFunction) _wrap_wxSizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_GetOption", (PyCFunction) _wrap_wxSizerItem_GetOption, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_GetSizer", (PyCFunction) _wrap_wxSizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_GetWindow", (PyCFunction) _wrap_wxSizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_IsSpacer", (PyCFunction) _wrap_wxSizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_IsSizer", (PyCFunction) _wrap_wxSizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_IsWindow", (PyCFunction) _wrap_wxSizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_SetDimension", (PyCFunction) _wrap_wxSizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_CalcMin", (PyCFunction) _wrap_wxSizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS },
+ { "wxSizerItem_GetSize", (PyCFunction) _wrap_wxSizerItem_GetSize, METH_VARARGS | METH_KEYWORDS },
+ { NULL, NULL }
+};
+#ifdef __cplusplus
+}
+#endif
+/*
+ * This table is used by the pointer type-checker
+ */
+static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
+ { "_wxAcceleratorTable","_class_wxAcceleratorTable",0},
+ { "_wxEvent","_class_wxEvent",0},
+ { "_class_wxActivateEvent","_wxActivateEvent",0},
+ { "_signed_long","_long",0},
+ { "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
+ { "_wxPrintQuality","_int",0},
+ { "_wxPrintQuality","_signed_int",0},
+ { "_wxPrintQuality","_unsigned_int",0},
+ { "_wxPrintQuality","_wxWindowID",0},
+ { "_wxPrintQuality","_uint",0},
+ { "_wxPrintQuality","_EBool",0},
+ { "_wxPrintQuality","_size_t",0},
+ { "_class_wxRegionIterator","_wxRegionIterator",0},
+ { "_class_wxMenuBar","_wxMenuBar",0},
+ { "_class_wxStaticBoxSizer","_wxStaticBoxSizer",0},
+ { "_class_wxEvtHandler","_wxEvtHandler",0},
+ { "_wxPaintEvent","_class_wxPaintEvent",0},
+ { "_wxPySizer","_class_wxPySizer",0},
+ { "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
+ { "_wxCursor","_class_wxCursor",0},
+ { "_wxNotifyEvent","_class_wxNotifyEvent",0},
+ { "_wxMask","_class_wxMask",0},
+ { "_wxPen","_class_wxPen",0},
+ { "_wxUpdateUIEvent","_class_wxUpdateUIEvent",0},
+ { "_byte","_unsigned_char",0},
+ { "_wxStaticBox","_class_wxStaticBox",0},
+ { "_wxChoice","_class_wxChoice",0},
+ { "_wxSlider","_class_wxSlider",0},
+ { "_long","_wxDash",0},
+ { "_long","_unsigned_long",0},
+ { "_long","_signed_long",0},
+ { "_wxImageList","_class_wxImageList",0},
+ { "_wxDropFilesEvent","_class_wxDropFilesEvent",0},
+ { "_wxBitmapButton","_class_wxBitmapButton",0},
+ { "_class_wxSizer","_class_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxSizer},
+ { "_class_wxSizer","_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxSizer},
+ { "_class_wxSizer","_class_wxBoxSizer",SwigwxBoxSizerTowxSizer},
+ { "_class_wxSizer","_wxBoxSizer",SwigwxBoxSizerTowxSizer},
+ { "_class_wxSizer","_class_wxPySizer",SwigwxPySizerTowxSizer},
+ { "_class_wxSizer","_wxPySizer",SwigwxPySizerTowxSizer},
+ { "_class_wxSizer","_wxSizer",0},
+ { "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
+ { "_class_wxGauge","_wxGauge",0},
+ { "_wxDC","_class_wxDC",0},
+ { "_wxSizerItem","_class_wxSizerItem",0},
+ { "_wxSpinEvent","_class_wxSpinEvent",0},
+ { "_size_t","_wxPrintQuality",0},
+ { "_size_t","_unsigned_int",0},
+ { "_size_t","_int",0},
+ { "_size_t","_wxWindowID",0},
+ { "_size_t","_uint",0},
+ { "_class_wxRealPoint","_wxRealPoint",0},
+ { "_wxPrinterDC","_class_wxPrinterDC",0},
+ { "_class_wxMenuItem","_wxMenuItem",0},
+ { "_class_wxPaintEvent","_wxPaintEvent",0},
+ { "_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0},
+ { "_class_wxPySizer","_wxPySizer",0},
+ { "_wxPanel","_class_wxPanel",0},
+ { "_wxInitDialogEvent","_class_wxInitDialogEvent",0},
+ { "_wxCheckBox","_class_wxCheckBox",0},
+ { "_wxPyEvent","_class_wxPyEvent",0},
+ { "_wxTextCtrl","_class_wxTextCtrl",0},
+ { "_class_wxMask","_wxMask",0},
+ { "_class_wxKeyEvent","_wxKeyEvent",0},
+ { "_wxColour","_class_wxColour",0},
+ { "_class_wxDialog","_wxDialog",0},
+ { "_wxIdleEvent","_class_wxIdleEvent",0},
+ { "_class_wxUpdateUIEvent","_wxUpdateUIEvent",0},
+ { "_wxStaticLine","_class_wxStaticLine",0},
+ { "_wxBrush","_class_wxBrush",0},
+ { "_wxShowEvent","_class_wxShowEvent",0},
+ { "_uint","_wxPrintQuality",0},
+ { "_uint","_size_t",0},
+ { "_uint","_unsigned_int",0},
+ { "_uint","_int",0},
+ { "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
+ { "_class_wxEvent","_wxEvent",0},
+ { "_wxCheckListBox","_class_wxCheckListBox",0},
+ { "_wxRect","_class_wxRect",0},
+ { "_wxCommandEvent","_class_wxCommandEvent",0},
+ { "_wxSizeEvent","_class_wxSizeEvent",0},
+ { "_wxPoint","_class_wxPoint",0},
+ { "_class_wxButton","_wxButton",0},
+ { "_wxRadioBox","_class_wxRadioBox",0},
+ { "_wxBoxSizer","_class_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxBoxSizer},
+ { "_wxBoxSizer","_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxBoxSizer},
+ { "_wxBoxSizer","_class_wxBoxSizer",0},
+ { "_wxBitmap","_class_wxBitmap",0},
+ { "_wxPyTimer","_class_wxPyTimer",0},
+ { "_wxWindowDC","_class_wxWindowDC",0},
+ { "_wxScrollBar","_class_wxScrollBar",0},
+ { "_wxSpinButton","_class_wxSpinButton",0},
+ { "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
+ { "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
+ { "_class_wxPyEvent","_wxPyEvent",0},
+ { "_class_wxIconizeEvent","_wxIconizeEvent",0},
+ { "_class_wxStaticBitmap","_wxStaticBitmap",0},
+ { "_class_wxStaticLine","_wxStaticLine",0},
+ { "_wxScrollEvent","_class_wxScrollEvent",0},
+ { "_EBool","_wxPrintQuality",0},
+ { "_EBool","_signed_int",0},
+ { "_EBool","_int",0},
+ { "_EBool","_wxWindowID",0},
+ { "_class_wxRegion","_wxRegion",0},
+ { "_class_wxDropFilesEvent","_wxDropFilesEvent",0},
+ { "_wxStaticText","_class_wxStaticText",0},
+ { "_wxFont","_class_wxFont",0},
+ { "_wxCloseEvent","_class_wxCloseEvent",0},
+ { "_unsigned_long","_wxDash",0},
+ { "_unsigned_long","_long",0},
+ { "_class_wxRect","_wxRect",0},
+ { "_class_wxDC","_wxDC",0},
+ { "_wxScrollWinEvent","_class_wxScrollWinEvent",0},
+ { "_class_wxPyTimer","_wxPyTimer",0},
+ { "_wxFocusEvent","_class_wxFocusEvent",0},
+ { "_wxMaximizeEvent","_class_wxMaximizeEvent",0},
+ { "_class_wxSpinButton","_wxSpinButton",0},
+ { "_wxAcceleratorEntry","_class_wxAcceleratorEntry",0},
+ { "_class_wxPanel","_wxPanel",0},
+ { "_class_wxCheckBox","_wxCheckBox",0},
+ { "_wxComboBox","_class_wxComboBox",0},
+ { "_wxRadioButton","_class_wxRadioButton",0},
+ { "_signed_int","_wxPrintQuality",0},
+ { "_signed_int","_EBool",0},
+ { "_signed_int","_wxWindowID",0},
+ { "_signed_int","_int",0},
+ { "_class_wxTextCtrl","_wxTextCtrl",0},
+ { "_wxLayoutConstraints","_class_wxLayoutConstraints",0},
+ { "_wxMetaFileDC","_class_wxMetaFileDC",0},
+ { "_wxMenu","_class_wxMenu",0},
+ { "_class_wxMoveEvent","_wxMoveEvent",0},
+ { "_wxListBox","_class_wxListBox",0},
+ { "_wxScreenDC","_class_wxScreenDC",0},
+ { "_WXTYPE","_short",0},
+ { "_WXTYPE","_signed_short",0},
+ { "_WXTYPE","_unsigned_short",0},
+ { "_class_wxBrush","_wxBrush",0},
+ { "_unsigned_short","_WXTYPE",0},
+ { "_unsigned_short","_short",0},
+ { "_class_wxWindow","_wxWindow",0},
+ { "_class_wxStaticText","_wxStaticText",0},
+ { "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
+ { "_class_wxCloseEvent","_wxCloseEvent",0},
+ { "_class_wxMenuEvent","_wxMenuEvent",0},
+ { "_wxClientDC","_class_wxClientDC",0},
+ { "_wxMouseEvent","_class_wxMouseEvent",0},
+ { "_class_wxPoint","_wxPoint",0},
+ { "_wxRealPoint","_class_wxRealPoint",0},
+ { "_class_wxRadioBox","_wxRadioBox",0},
+ { "_class_wxBoxSizer","_class_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxBoxSizer},
+ { "_class_wxBoxSizer","_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxBoxSizer},
+ { "_class_wxBoxSizer","_wxBoxSizer",0},
+ { "_signed_short","_WXTYPE",0},
+ { "_signed_short","_short",0},
+ { "_wxMemoryDC","_class_wxMemoryDC",0},
+ { "_wxPaintDC","_class_wxPaintDC",0},
+ { "_class_wxWindowDC","_wxWindowDC",0},
+ { "_class_wxFocusEvent","_wxFocusEvent",0},
+ { "_class_wxMaximizeEvent","_wxMaximizeEvent",0},
+ { "_class_wxAcceleratorEntry","_wxAcceleratorEntry",0},
+ { "_class_wxCursor","_wxCursor",0},
+ { "_wxScrolledWindow","_class_wxScrolledWindow",0},
+ { "_unsigned_char","_byte",0},
+ { "_class_wxMetaFileDC","_wxMetaFileDC",0},
+ { "_class_wxMenu","_wxMenu",0},
+ { "_wxControl","_class_wxControl",0},
+ { "_class_wxListBox","_wxListBox",0},
+ { "_unsigned_int","_wxPrintQuality",0},
+ { "_unsigned_int","_size_t",0},
+ { "_unsigned_int","_uint",0},
+ { "_unsigned_int","_wxWindowID",0},
+ { "_unsigned_int","_int",0},
+ { "_wxIcon","_class_wxIcon",0},
+ { "_wxDialog","_class_wxDialog",0},
+ { "_class_wxPen","_wxPen",0},
+ { "_short","_WXTYPE",0},
+ { "_short","_unsigned_short",0},
+ { "_short","_signed_short",0},
+ { "_class_wxStaticBox","_wxStaticBox",0},
+ { "_class_wxScrollEvent","_wxScrollEvent",0},
+ { "_wxJoystickEvent","_class_wxJoystickEvent",0},
+ { "_class_wxChoice","_wxChoice",0},
+ { "_class_wxSlider","_wxSlider",0},
+ { "_class_wxImageList","_wxImageList",0},
+ { "_class_wxBitmapButton","_wxBitmapButton",0},
+ { "_wxWindowID","_wxPrintQuality",0},
+ { "_wxWindowID","_size_t",0},
+ { "_wxWindowID","_EBool",0},
+ { "_wxWindowID","_uint",0},
+ { "_wxWindowID","_int",0},
+ { "_wxWindowID","_signed_int",0},
+ { "_wxWindowID","_unsigned_int",0},
+ { "_class_wxScrollWinEvent","_wxScrollWinEvent",0},
+ { "_class_wxSizerItem","_wxSizerItem",0},
+ { "_int","_wxPrintQuality",0},
+ { "_int","_size_t",0},
+ { "_int","_EBool",0},
+ { "_int","_uint",0},
+ { "_int","_wxWindowID",0},
+ { "_int","_unsigned_int",0},
+ { "_int","_signed_int",0},
+ { "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
+ { "_class_wxSpinEvent","_wxSpinEvent",0},
+ { "_wxButton","_class_wxButton",0},
+ { "_wxSize","_class_wxSize",0},
+ { "_wxRegionIterator","_class_wxRegionIterator",0},
+ { "_class_wxPrinterDC","_wxPrinterDC",0},
+ { "_wxStaticBoxSizer","_class_wxStaticBoxSizer",0},
+ { "_class_wxPaintDC","_wxPaintDC",0},
+ { "_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0},
+ { "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
+ { "_class_wxComboBox","_wxComboBox",0},
+ { "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
+ { "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
+ { "_wxIconizeEvent","_class_wxIconizeEvent",0},
+ { "_class_wxControl","_wxControl",0},
+ { "_wxStaticBitmap","_class_wxStaticBitmap",0},
+ { "_class_wxIcon","_wxIcon",0},
+ { "_class_wxColour","_wxColour",0},
+ { "_class_wxScreenDC","_wxScreenDC",0},
+ { "_wxPalette","_class_wxPalette",0},
+ { "_class_wxIdleEvent","_wxIdleEvent",0},
+ { "_wxEraseEvent","_class_wxEraseEvent",0},
+ { "_class_wxJoystickEvent","_wxJoystickEvent",0},
+ { "_wxRegion","_class_wxRegion",0},
+ { "_wxSizer","_class_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxSizer},
+ { "_wxSizer","_wxStaticBoxSizer",SwigwxStaticBoxSizerTowxSizer},
+ { "_wxSizer","_class_wxBoxSizer",SwigwxBoxSizerTowxSizer},
+ { "_wxSizer","_wxBoxSizer",SwigwxBoxSizerTowxSizer},
+ { "_wxSizer","_class_wxPySizer",SwigwxPySizerTowxSizer},
+ { "_wxSizer","_wxPySizer",SwigwxPySizerTowxSizer},
+ { "_wxSizer","_class_wxSizer",0},
+ { "_class_wxShowEvent","_wxShowEvent",0},
+ { "_wxActivateEvent","_class_wxActivateEvent",0},
+ { "_wxGauge","_class_wxGauge",0},
+ { "_class_wxCheckListBox","_wxCheckListBox",0},
+ { "_class_wxCommandEvent","_wxCommandEvent",0},
+ { "_class_wxClientDC","_wxClientDC",0},
+ { "_class_wxSizeEvent","_wxSizeEvent",0},
+ { "_class_wxSize","_wxSize",0},
+ { "_class_wxBitmap","_wxBitmap",0},
+ { "_class_wxMemoryDC","_wxMemoryDC",0},
+ { "_wxMenuBar","_class_wxMenuBar",0},
+ { "_wxEvtHandler","_class_wxEvtHandler",0},
+ { "_wxMenuItem","_class_wxMenuItem",0},
+ { "_class_wxScrollBar","_wxScrollBar",0},
+ { "_wxDash","_unsigned_long",0},
+ { "_wxDash","_long",0},
+ { "_class_wxScrolledWindow","_wxScrolledWindow",0},
+ { "_wxKeyEvent","_class_wxKeyEvent",0},
+ { "_wxMoveEvent","_class_wxMoveEvent",0},
+ { "_class_wxPalette","_wxPalette",0},
+ { "_class_wxEraseEvent","_wxEraseEvent",0},
+ { "_wxWindow","_class_wxWindow",0},
+{0,0,0}};
+
+static PyObject *SWIG_globals;
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT(void) initsizersc() {
+ PyObject *m, *d;
+ SWIG_globals = SWIG_newvarlink();
+ m = Py_InitModule("sizersc", sizerscMethods);
+ d = PyModule_GetDict(m);
+{
+ int i;
+ for (i = 0; _swig_mapping[i].n1; i++)
+ SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
+}
+}
--- /dev/null
+# This file was created automatically by SWIG.
+import sizersc
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from controls import *
+
+from events import *
+import wx
+import string
+class wxSizerItemPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def GetSize(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_GetSize,(self,) + _args, _kwargs)
+ if val: val = wxSizePtr(val) ; val.thisown = 1
+ return val
+ def CalcMin(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_CalcMin,(self,) + _args, _kwargs)
+ if val: val = wxSizePtr(val) ; val.thisown = 1
+ return val
+ def SetDimension(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_SetDimension,(self,) + _args, _kwargs)
+ return val
+ def IsWindow(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_IsWindow,(self,) + _args, _kwargs)
+ return val
+ def IsSizer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_IsSizer,(self,) + _args, _kwargs)
+ return val
+ def IsSpacer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_IsSpacer,(self,) + _args, _kwargs)
+ return val
+ def GetWindow(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_GetWindow,(self,) + _args, _kwargs)
+ if val: val = wxWindowPtr(val)
+ return val
+ def GetSizer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_GetSizer,(self,) + _args, _kwargs)
+ if val: val = wxSizerPtr(val)
+ return val
+ def GetOption(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_GetOption,(self,) + _args, _kwargs)
+ return val
+ def GetFlag(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_GetFlag,(self,) + _args, _kwargs)
+ return val
+ def GetBorder(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_GetBorder,(self,) + _args, _kwargs)
+ return val
+ def GetUserData(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizerItem_GetUserData,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxSizerItem instance at %s>" % (self.this,)
+class wxSizerItem(wxSizerItemPtr):
+ def __init__(self,this):
+ self.this = this
+
+
+
+
+class wxSizerPtr :
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def Destroy(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_Destroy,(self,) + _args, _kwargs)
+ return val
+ def AddWindow(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_AddWindow,(self,) + _args, _kwargs)
+ return val
+ def AddSizer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_AddSizer,(self,) + _args, _kwargs)
+ return val
+ def AddSpacer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_AddSpacer,(self,) + _args, _kwargs)
+ return val
+ def PrependWindow(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_PrependWindow,(self,) + _args, _kwargs)
+ return val
+ def PrependSizer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_PrependSizer,(self,) + _args, _kwargs)
+ return val
+ def PrependSpacer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_PrependSpacer,(self,) + _args, _kwargs)
+ return val
+ def RemoveWindow(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_RemoveWindow,(self,) + _args, _kwargs)
+ return val
+ def RemoveSizer(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_RemoveSizer,(self,) + _args, _kwargs)
+ return val
+ def RemovePos(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_RemovePos,(self,) + _args, _kwargs)
+ return val
+ def SetDimension(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_SetDimension,(self,) + _args, _kwargs)
+ return val
+ def GetSize(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_GetSize,(self,) + _args, _kwargs)
+ if val: val = wxSizePtr(val) ; val.thisown = 1
+ return val
+ def GetPosition(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_GetPosition,(self,) + _args, _kwargs)
+ if val: val = wxPointPtr(val) ; val.thisown = 1
+ return val
+ def GetMinSize(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_GetMinSize,(self,) + _args, _kwargs)
+ if val: val = wxSizePtr(val) ; val.thisown = 1
+ return val
+ def Layout(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_Layout,(self,) + _args, _kwargs)
+ return val
+ def Fit(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_Fit,(self,) + _args, _kwargs)
+ return val
+ def SetSizeHints(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_SetSizeHints,(self,) + _args, _kwargs)
+ return val
+ def GetChildren(self, *_args, **_kwargs):
+ val = apply(sizersc.wxSizer_GetChildren,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxSizer instance at %s>" % (self.this,)
+
+ def Add(self, *args):
+ if type(args[0]) == type(1):
+ apply(self.AddSpacer, args)
+ elif string.find(args[0].this, 'Sizer') != -1:
+ apply(self.AddSizer, args)
+ else:
+ apply(self.AddWindow, args)
+
+ def Prepend(self, *args):
+ if type(args[0]) == type(1):
+ apply(self.PrependSpacer, args)
+ elif string.find(args[0].this, 'Sizer') != -1:
+ apply(self.PrependSizer, args)
+ else:
+ apply(self.PrependWindow, args)
+
+ def Remove(self, *args):
+ if type(args[0]) == type(1):
+ apply(self.RemovePos, args)
+ elif string.find(args[0].this, 'Sizer') != -1:
+ apply(self.RemoveSizer, args)
+ else:
+ apply(self.RemoveWindow, args)
+
+ def AddMany(self, widgets):
+ for childinfo in widgets:
+ if type(childinfo) != type(()):
+ childinfo = (childinfo, )
+ apply(self.Add, childinfo)
+
+class wxSizer(wxSizerPtr):
+ def __init__(self,this):
+ self.this = this
+
+
+
+
+class wxPySizerPtr(wxSizerPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def _setSelf(self, *_args, **_kwargs):
+ val = apply(sizersc.wxPySizer__setSelf,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxPySizer instance at %s>" % (self.this,)
+class wxPySizer(wxPySizerPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(sizersc.new_wxPySizer,_args,_kwargs)
+ self.thisown = 1
+ self._setSelf(self)
+
+
+
+
+class wxBoxSizerPtr(wxSizerPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def GetOrientation(self, *_args, **_kwargs):
+ val = apply(sizersc.wxBoxSizer_GetOrientation,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxBoxSizer instance at %s>" % (self.this,)
+class wxBoxSizer(wxBoxSizerPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(sizersc.new_wxBoxSizer,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxStaticBoxSizerPtr(wxBoxSizerPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def GetStaticBox(self, *_args, **_kwargs):
+ val = apply(sizersc.wxStaticBoxSizer_GetStaticBox,(self,) + _args, _kwargs)
+ if val: val = wxStaticBoxPtr(val)
+ return val
+ def __repr__(self):
+ return "<C wxStaticBoxSizer instance at %s>" % (self.this,)
+class wxStaticBoxSizer(wxStaticBoxSizerPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(sizersc.new_wxStaticBoxSizer,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __cplusplus
extern "C" {
long _arg4 = (long ) wxST_SIZEGRIP;
char * _arg5 = (char *) "statusBar";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxStatusBar",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxStatusBar",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxStatusBar. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxStatusBar. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxStatusBar *)new_wxStatusBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
long _arg4 = (long ) wxTB_HORIZONTAL|wxNO_BORDER;
char * _arg5 = (char *) "toolBar";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxToolBar",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxToolBar",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxToolBar. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxToolBar. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxToolBar *)new_wxToolBar(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
wxToolBar * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","size", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxToolBar_SetToolBitmapSize",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxToolBar_SetToolBitmapSize",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxToolBar_SetToolBitmapSize. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxToolBar_SetToolBitmapSize(_arg0,*_arg1);
wxToolBar * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","size", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxToolBar_SetMargins",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxToolBar_SetMargins",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxToolBar_SetMargins. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxToolBar_SetMargins(_arg0,*_arg1);
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxCheckListBox","_class_wxCheckListBox",0},
{ "_wxRect","_class_wxRect",0},
{ "_wxToolBarTool","_class_wxToolBarTool",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticBitmap","_wxStaticBitmap",0},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_wxSize","_class_wxSize",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_class_wxToolBar",SwigwxToolBarTowxControl},
return target;
}
+static char* wxStringErrorMsg = "string type is required for parameter";
+
+ bool wxValidator_IsSilent() {
+ return wxValidator::IsSilent();
+ }
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+ void wxValidator_SetBellOnError(int doIt = TRUE) {
+ wxValidator::SetBellOnError(doIt);
+ }
+class wxPyValidator : public wxValidator {
+ DECLARE_DYNAMIC_CLASS(wxPyValidator);
+public:
+ wxPyValidator() {
+ }
+// wxPyValidator(const wxPyValidator& other);
+
+ ~wxPyValidator() {
+ }
+
+ wxObject* wxPyValidator::Clone() const {
+ wxPyValidator* ptr = NULL;
+ wxPyValidator* self = (wxPyValidator*)this;
+
+ bool doSave = wxPyRestoreThread();
+ if (self->m_myInst.findCallback("Clone")) {
+ PyObject* ro;
+ ro = self->m_myInst.callCallbackObj(Py_BuildValue("()"));
+ SWIG_GetPtrObj(ro, (void **)&ptr, "_wxPyValidator_p");
+ }
+ // This is very dangerous!!! But is the only way I could find
+ // to squash a memory leak. Currently it is okay, but if the
+ // validator architecture in wxWindows ever changes, problems
+ // could arise.
+ delete self;
+
+ wxPySaveThread(doSave);
+ return ptr;
+}
+
+
+ DEC_PYCALLBACK_BOOL_WXWIN(Validate);
+ DEC_PYCALLBACK_BOOL_(TransferToWindow);
+ DEC_PYCALLBACK_BOOL_(TransferFromWindow);
+
+ PYPRIVATE;
+// PyObject* m_data;
+};
+
+IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
+IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
+IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
+
+IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
-static char* wxStringErrorMsg = "string type is required for parameter";
wxWindow* wxWindow_FindFocus() {
return wxWindow::FindFocus();
}
-
-wxWindow* wxWindow_FromHWND(unsigned long hWnd) {
- wxWindow* win = new wxWindow;
- win->SetHWND(hWnd);
- win->SubclassWin(hWnd);
- return win;
+
+wxWindow* wxWindow_FromHWND(unsigned long hWnd) {
+ wxWindow* win = new wxWindow;
+ win->SetHWND(hWnd);
+ win->SubclassWin(hWnd);
+ return win;
+}
+#ifdef __cplusplus
+extern "C" {
+#endif
+static PyObject *_wrap_wxValidator_IsSilent(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ char *_kwnames[] = { NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxValidator_IsSilent",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxValidator_IsSilent();
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+static PyObject *_wrap_wxValidator_SetBellOnError(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ int _arg0 = (int ) TRUE;
+ char *_kwnames[] = { "doIt", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|i:wxValidator_SetBellOnError",_kwnames,&_arg0))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxValidator_SetBellOnError(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static PyObject *_wrap_wxWindow_FindFocus(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxWindow_FindFocus",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxWindow *)wxWindow_FindFocus();
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+static PyObject *_wrap_wxWindow_FromHWND(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _result;
+ unsigned long _arg0;
+ char *_kwnames[] = { "hWnd", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"l:wxWindow_FromHWND",_kwnames,&_arg0))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxWindow *)wxWindow_FromHWND(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxEvtHandler_ProcessEvent(_swigobj,_swigarg0) (_swigobj->ProcessEvent(_swigarg0))
+static PyObject *_wrap_wxEvtHandler_ProcessEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxEvtHandler * _arg0;
+ wxEvent * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","event", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEvtHandler_ProcessEvent",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_ProcessEvent. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(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;
+}
+
+#define wxEvtHandler_GetEvtHandlerEnabled(_swigobj) (_swigobj->GetEvtHandlerEnabled())
+static PyObject *_wrap_wxEvtHandler_GetEvtHandlerEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxEvtHandler * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEvtHandler_GetEvtHandlerEnabled",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_GetEvtHandlerEnabled. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxEvtHandler_GetEvtHandlerEnabled(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
+#define wxEvtHandler_SetEvtHandlerEnabled(_swigobj,_swigarg0) (_swigobj->SetEvtHandlerEnabled(_swigarg0))
+static PyObject *_wrap_wxEvtHandler_SetEvtHandlerEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEvtHandler * _arg0;
+ bool _arg1;
+ PyObject * _argo0 = 0;
+ int tempbool1;
+ char *_kwnames[] = { "self","enabled", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxEvtHandler_SetEvtHandlerEnabled",_kwnames,&_argo0,&tempbool1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_SetEvtHandlerEnabled. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+ _arg1 = (bool ) tempbool1;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxEvtHandler_SetEvtHandlerEnabled(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEvtHandler_GetNextHandler(_swigobj) (_swigobj->GetNextHandler())
+static PyObject *_wrap_wxEvtHandler_GetNextHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEvtHandler * _result;
+ wxEvtHandler * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEvtHandler_GetNextHandler",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_GetNextHandler. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxEvtHandler *)wxEvtHandler_GetNextHandler(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxEvtHandler_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxEvtHandler_GetPreviousHandler(_swigobj) (_swigobj->GetPreviousHandler())
+static PyObject *_wrap_wxEvtHandler_GetPreviousHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEvtHandler * _result;
+ wxEvtHandler * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxEvtHandler_GetPreviousHandler",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_GetPreviousHandler. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxEvtHandler *)wxEvtHandler_GetPreviousHandler(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxEvtHandler_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxEvtHandler_SetNextHandler(_swigobj,_swigarg0) (_swigobj->SetNextHandler(_swigarg0))
+static PyObject *_wrap_wxEvtHandler_SetNextHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEvtHandler * _arg0;
+ wxEvtHandler * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","handler", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEvtHandler_SetNextHandler",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_SetNextHandler. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxEvtHandler_SetNextHandler. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxEvtHandler_SetNextHandler(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxEvtHandler_SetPreviousHandler(_swigobj,_swigarg0) (_swigobj->SetPreviousHandler(_swigarg0))
+static PyObject *_wrap_wxEvtHandler_SetPreviousHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEvtHandler * _arg0;
+ wxEvtHandler * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","handler", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEvtHandler_SetPreviousHandler",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_SetPreviousHandler. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxEvtHandler_SetPreviousHandler. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxEvtHandler_SetPreviousHandler(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ 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,
+ (wxObjectEventFunction) &wxPyCallback::EventThunker,
+ new wxPyCallback(func));
+ }
+ }
+static PyObject *_wrap_wxEvtHandler_Connect(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxEvtHandler * _arg0;
+ int _arg1;
+ int _arg2;
+ int _arg3;
+ PyObject * _arg4;
+ PyObject * _argo0 = 0;
+ PyObject * _obj4 = 0;
+ char *_kwnames[] = { "self","id","lastId","eventType","func", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiiO:wxEvtHandler_Connect",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_obj4))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_Connect. Expected _wxEvtHandler_p.");
+ return NULL;
+ }
+ }
+{
+ _arg4 = _obj4;
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxEvtHandler_Connect(_arg0,_arg1,_arg2,_arg3,_arg4);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+static void *SwigwxValidatorTowxEvtHandler(void *ptr) {
+ wxValidator *src;
+ wxEvtHandler *dest;
+ src = (wxValidator *) ptr;
+ dest = (wxEvtHandler *) src;
+ return (void *) dest;
+}
+
+#define new_wxValidator() (new wxValidator())
+static PyObject *_wrap_new_wxValidator(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxValidator * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxValidator",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxValidator *)new_wxValidator();
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxValidator_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
}
-#ifdef __cplusplus
-extern "C" {
-#endif
-static PyObject *_wrap_wxWindow_FindFocus(PyObject *self, PyObject *args, PyObject *kwargs) {
+
+#define wxValidator_Clone(_swigobj) (_swigobj->Clone())
+static PyObject *_wrap_wxValidator_Clone(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
- wxWindow * _result;
- char *_kwnames[] = { NULL };
+ wxValidator * _result;
+ wxValidator * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxWindow_FindFocus",_kwnames))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxValidator_Clone",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxValidator_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxValidator_Clone. Expected _wxValidator_p.");
return NULL;
+ }
+ }
{
wxPy_BEGIN_ALLOW_THREADS;
- _result = (wxWindow *)wxWindow_FindFocus();
+ _result = (wxValidator *)wxValidator_Clone(_arg0);
wxPy_END_ALLOW_THREADS;
} if (_result) {
- SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxValidator_p");
_resultobj = Py_BuildValue("s",_ptemp);
} else {
Py_INCREF(Py_None);
return _resultobj;
}
-static PyObject *_wrap_wxWindow_FromHWND(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxValidator_GetWindow(_swigobj) (_swigobj->GetWindow())
+static PyObject *_wrap_wxValidator_GetWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxWindow * _result;
- unsigned long _arg0;
- char *_kwnames[] = { "hWnd", NULL };
+ wxValidator * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"l:wxWindow_FromHWND",_kwnames,&_arg0))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxValidator_GetWindow",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxValidator_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxValidator_GetWindow. Expected _wxValidator_p.");
return NULL;
+ }
+ }
{
wxPy_BEGIN_ALLOW_THREADS;
- _result = (wxWindow *)wxWindow_FromHWND(_arg0);
+ _result = (wxWindow *)wxValidator_GetWindow(_arg0);
wxPy_END_ALLOW_THREADS;
} if (_result) {
return _resultobj;
}
-#define wxEvtHandler_ProcessEvent(_swigobj,_swigarg0) (_swigobj->ProcessEvent(_swigarg0))
-static PyObject *_wrap_wxEvtHandler_ProcessEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
+#define wxValidator_SetWindow(_swigobj,_swigarg0) (_swigobj->SetWindow(_swigarg0))
+static PyObject *_wrap_wxValidator_SetWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
- bool _result;
- wxEvtHandler * _arg0;
- wxEvent * _arg1;
+ wxValidator * _arg0;
+ wxWindow * _arg1;
PyObject * _argo0 = 0;
PyObject * _argo1 = 0;
- char *_kwnames[] = { "self","event", NULL };
+ char *_kwnames[] = { "self","window", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxEvtHandler_ProcessEvent",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxValidator_SetWindow",_kwnames,&_argo0,&_argo1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_ProcessEvent. Expected _wxEvtHandler_p.");
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxValidator_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxValidator_SetWindow. Expected _wxValidator_p.");
return NULL;
}
}
if (_argo1) {
if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxEvent_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxEvtHandler_ProcessEvent. Expected _wxEvent_p.");
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxValidator_SetWindow. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
- _result = (bool )wxEvtHandler_ProcessEvent(_arg0,*_arg1);
+ wxValidator_SetWindow(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
-} _resultobj = Py_BuildValue("i",_result);
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
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,
- (wxObjectEventFunction) &wxPyCallback::EventThunker,
- new wxPyCallback(func));
- }
+static void *SwigwxPyValidatorTowxValidator(void *ptr) {
+ wxPyValidator *src;
+ wxValidator *dest;
+ src = (wxPyValidator *) ptr;
+ dest = (wxValidator *) src;
+ return (void *) dest;
+}
+
+static void *SwigwxPyValidatorTowxEvtHandler(void *ptr) {
+ wxPyValidator *src;
+ wxEvtHandler *dest;
+ src = (wxPyValidator *) ptr;
+ dest = (wxEvtHandler *) src;
+ return (void *) dest;
+}
+
+#define new_wxPyValidator() (new wxPyValidator())
+static PyObject *_wrap_new_wxPyValidator(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxPyValidator * _result;
+ char *_kwnames[] = { NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyValidator",_kwnames))
+ return NULL;
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxPyValidator *)new_wxPyValidator();
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyValidator_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+static void wxPyValidator_Destroy(wxPyValidator *self) { delete self; }
+static PyObject *_wrap_wxPyValidator_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxPyValidator * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyValidator_Destroy",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyValidator_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyValidator_Destroy. Expected _wxPyValidator_p.");
+ return NULL;
}
-static PyObject *_wrap_wxEvtHandler_Connect(PyObject *self, PyObject *args, PyObject *kwargs) {
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxPyValidator_Destroy(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxPyValidator__setSelf(_swigobj,_swigarg0,_swigarg1) (_swigobj->_setSelf(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxPyValidator__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
- wxEvtHandler * _arg0;
- int _arg1;
- int _arg2;
- int _arg3;
- PyObject * _arg4;
+ wxPyValidator * _arg0;
+ PyObject * _arg1;
+ int _arg2 = (int ) TRUE;
PyObject * _argo0 = 0;
- PyObject * _obj4 = 0;
- char *_kwnames[] = { "self","id","lastId","eventType","func", NULL };
+ PyObject * _obj1 = 0;
+ char *_kwnames[] = { "self","self","incref", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiiO:wxEvtHandler_Connect",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_obj4))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxPyValidator__setSelf",_kwnames,&_argo0,&_obj1,&_arg2))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxEvtHandler_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxEvtHandler_Connect. Expected _wxEvtHandler_p.");
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyValidator_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyValidator__setSelf. Expected _wxPyValidator_p.");
return NULL;
}
}
{
- _arg4 = _obj4;
+ _arg1 = _obj1;
}
{
wxPy_BEGIN_ALLOW_THREADS;
- wxEvtHandler_Connect(_arg0,_arg1,_arg2,_arg3,_arg4);
+ wxPyValidator__setSelf(_arg0,_arg1,_arg2);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
long _arg4 = (long ) 0;
char * _arg5 = (char *) "panel";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxWindow",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxWindow. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxWindow. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)new_wxWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
wxWindow * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ClientToScreen",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ClientToScreen",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_ClientToScreen. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxPoint (wxWindow_ClientToScreen(_arg0,*_arg1));
wxWindow * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","point", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_Move",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_Move",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_Move. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_Move(_arg0,*_arg1);
wxPoint * _arg2;
PyObject * _argo0 = 0;
PyObject * _argo1 = 0;
- PyObject * _argo2 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
char *_kwnames[] = { "self","menu","pos", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxWindow_PopupMenu",_kwnames,&_argo0,&_argo1,&_argo2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxWindow_PopupMenu",_kwnames,&_argo0,&_argo1,&_obj2))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxWindow_PopupMenu. Expected _wxPoint_p.");
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxWindow_PopupMenu(_arg0,_arg1,*_arg2);
wxRect * _arg2 = (wxRect *) NULL;
PyObject * _argo0 = 0;
int tempbool1 = (int) TRUE;
- PyObject * _argo2 = 0;
+ wxRect temp;
+ PyObject * _obj2 = 0;
char *_kwnames[] = { "self","eraseBackground","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iO:wxWindow_Refresh",_kwnames,&_argo0,&tempbool1,&_argo2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iO:wxWindow_Refresh",_kwnames,&_argo0,&tempbool1,&_obj2))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
}
_arg1 = (bool ) tempbool1;
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxWindow_Refresh. Expected _wxRect_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxRect_helper(_obj2, &_arg2))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_Refresh(_arg0,_arg1,_arg2);
wxWindow * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ScreenToClient",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ScreenToClient",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_ScreenToClient. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxPoint (wxWindow_ScreenToClient(_arg0,*_arg1));
int _arg2;
wxRect * _arg3 = (wxRect *) NULL;
PyObject * _argo0 = 0;
- PyObject * _argo3 = 0;
+ wxRect temp;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "self","dx","dy","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|O:wxWindow_ScrollWindow",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|O:wxWindow_ScrollWindow",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxWindow_ScrollWindow. Expected _wxRect_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxRect_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_ScrollWindow(_arg0,_arg1,_arg2,_arg3);
return _resultobj;
}
+#define wxWindow_UnsetConstraints(_swigobj,_swigarg0) (_swigobj->UnsetConstraints(_swigarg0))
+static PyObject *_wrap_wxWindow_UnsetConstraints(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _arg0;
+ wxLayoutConstraints * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","constraints", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_UnsetConstraints",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_UnsetConstraints. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxLayoutConstraints_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_UnsetConstraints. Expected _wxLayoutConstraints_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxWindow_UnsetConstraints(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
#define wxWindow_SetFocus(_swigobj) (_swigobj->SetFocus())
static PyObject *_wrap_wxWindow_SetFocus(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
+#define wxWindow_AcceptsFocus(_swigobj) (_swigobj->AcceptsFocus())
+static PyObject *_wrap_wxWindow_AcceptsFocus(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ bool _result;
+ wxWindow * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_AcceptsFocus",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_AcceptsFocus. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (bool )wxWindow_AcceptsFocus(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} _resultobj = Py_BuildValue("i",_result);
+ return _resultobj;
+}
+
#define wxWindow_SetFont(_swigobj,_swigarg0) (_swigobj->SetFont(_swigarg0))
static PyObject *_wrap_wxWindow_SetFont(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
wxWindow * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","size", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetSize",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetSize",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_SetSize. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_SetSize(_arg0,*_arg1);
wxWindow * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pos", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetPosition",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetPosition",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_SetPosition. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_SetPosition(_arg0,*_arg1);
wxWindow * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","size", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetClientSize",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetClientSize",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_SetClientSize. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_SetClientSize(_arg0,*_arg1);
wxWindow * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertDialogPointToPixels",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertDialogPointToPixels",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_ConvertDialogPointToPixels. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxPoint (wxWindow_ConvertDialogPointToPixels(_arg0,*_arg1));
wxWindow * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","sz", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertDialogSizeToPixels",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertDialogSizeToPixels",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_ConvertDialogSizeToPixels. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxSize (wxWindow_ConvertDialogSizeToPixels(_arg0,*_arg1));
wxWindow * _arg0;
wxPoint * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxPoint temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","pt", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertPixelPointToDialog",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertPixelPointToDialog",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_ConvertPixelPointToDialog. Expected _wxPoint_p.");
+{
+ _arg1 = &temp;
+ if (! wxPoint_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxPoint (wxWindow_ConvertPixelPointToDialog(_arg0,*_arg1));
wxWindow * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","sz", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertPixelSizeToDialog",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_ConvertPixelSizeToDialog",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_ConvertPixelSizeToDialog. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxSize (wxWindow_ConvertPixelSizeToDialog(_arg0,*_arg1));
return _resultobj;
}
+#define wxWindow_SetSizer(_swigobj,_swigarg0) (_swigobj->SetSizer(_swigarg0))
+static PyObject *_wrap_wxWindow_SetSizer(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _arg0;
+ wxSizer * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","sizer", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetSizer",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_SetSizer. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSizer_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_SetSizer. Expected _wxSizer_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxWindow_SetSizer(_arg0,_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
+#define wxWindow_GetValidator(_swigobj) (_swigobj->GetValidator())
+static PyObject *_wrap_wxWindow_GetValidator(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxValidator * _result;
+ wxWindow * _arg0;
+ PyObject * _argo0 = 0;
+ char *_kwnames[] = { "self", NULL };
+ char _ptemp[128];
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxWindow_GetValidator",_kwnames,&_argo0))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_GetValidator. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ _result = (wxValidator *)wxWindow_GetValidator(_arg0);
+
+ wxPy_END_ALLOW_THREADS;
+} if (_result) {
+ SWIG_MakePtr(_ptemp, (char *) _result,"_wxValidator_p");
+ _resultobj = Py_BuildValue("s",_ptemp);
+ } else {
+ Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ }
+ return _resultobj;
+}
+
+#define wxWindow_SetValidator(_swigobj,_swigarg0) (_swigobj->SetValidator(_swigarg0))
+static PyObject *_wrap_wxWindow_SetValidator(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxWindow * _arg0;
+ wxValidator * _arg1;
+ PyObject * _argo0 = 0;
+ PyObject * _argo1 = 0;
+ char *_kwnames[] = { "self","validator", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxWindow_SetValidator",_kwnames,&_argo0,&_argo1))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_SetValidator. Expected _wxWindow_p.");
+ return NULL;
+ }
+ }
+ if (_argo1) {
+ if (_argo1 == Py_None) { _arg1 = NULL; }
+ else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxValidator_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_SetValidator. Expected _wxValidator_p.");
+ return NULL;
+ }
+ }
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxWindow_SetValidator(_arg0,*_arg1);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+ return _resultobj;
+}
+
static void *SwigwxPanelTowxWindow(void *ptr) {
wxPanel *src;
wxWindow *dest;
long _arg4 = (long ) wxTAB_TRAVERSAL;
char * _arg5 = (char *) "panel";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxPanel",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxPanel",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxPanel. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxPanel. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxPanel *)new_wxPanel(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
char * _arg6 = (char *) "dialogBox";
PyObject * _argo0 = 0;
PyObject * _obj2 = 0;
- PyObject * _argo3 = 0;
- PyObject * _argo4 = 0;
+ wxPoint temp;
+ PyObject * _obj3 = 0;
+ wxSize temp0;
+ PyObject * _obj4 = 0;
char *_kwnames[] = { "parent","id","title","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxDialog",_kwnames,&_argo0,&_arg1,&_obj2,&_argo3,&_argo4,&_arg5,&_arg6))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO|OOls:new_wxDialog",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_obj4,&_arg5,&_arg6))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
}
_arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
}
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxDialog. Expected _wxPoint_p.");
+ if (_obj3)
+{
+ _arg3 = &temp;
+ if (! wxPoint_helper(_obj3, &_arg3))
return NULL;
- }
- }
- if (_argo4) {
- if (_argo4 == Py_None) { _arg4 = NULL; }
- else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxDialog. Expected _wxSize_p.");
+}
+ if (_obj4)
+{
+ _arg4 = &temp0;
+ if (! wxSize_helper(_obj4, &_arg4))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxDialog *)new_wxDialog(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
long _arg4 = (long ) wxHSCROLL|wxVSCROLL;
char * _arg5 = (char *) "scrolledWindow";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOls:new_wxScrolledWindow",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOls:new_wxScrolledWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxScrolledWindow. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxScrolledWindow. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxScrolledWindow *)new_wxScrolledWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
return _resultobj;
}
+#define wxMenuBar_SetLabel(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetLabel(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMenuBar_SetLabel(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject * _resultobj;
+ wxMenuBar * _arg0;
+ int _arg1;
+ wxString * _arg2;
+ PyObject * _argo0 = 0;
+ PyObject * _obj2 = 0;
+ char *_kwnames[] = { "self","id","label", NULL };
+
+ self = self;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxMenuBar_SetLabel",_kwnames,&_argo0,&_arg1,&_obj2))
+ return NULL;
+ if (_argo0) {
+ if (_argo0 == Py_None) { _arg0 = NULL; }
+ else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMenuBar_p")) {
+ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuBar_SetLabel. Expected _wxMenuBar_p.");
+ return NULL;
+ }
+ }
+{
+ if (!PyString_Check(_obj2)) {
+ PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+ return NULL;
+ }
+ _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
+}
+{
+ wxPy_BEGIN_ALLOW_THREADS;
+ wxMenuBar_SetLabel(_arg0,_arg1,*_arg2);
+
+ wxPy_END_ALLOW_THREADS;
+} Py_INCREF(Py_None);
+ _resultobj = Py_None;
+{
+ if (_obj2)
+ delete _arg2;
+}
+ return _resultobj;
+}
+
#define wxMenuBar_EnableTop(_swigobj,_swigarg0,_swigarg1) (_swigobj->EnableTop(_swigarg0,_swigarg1))
static PyObject *_wrap_wxMenuBar_EnableTop(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
return _resultobj;
}
-#define wxMenuBar_SetLabel(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetLabel(_swigarg0,_swigarg1))
-static PyObject *_wrap_wxMenuBar_SetLabel(PyObject *self, PyObject *args, PyObject *kwargs) {
- PyObject * _resultobj;
- wxMenuBar * _arg0;
- int _arg1;
- wxString * _arg2;
- PyObject * _argo0 = 0;
- PyObject * _obj2 = 0;
- char *_kwnames[] = { "self","id","label", NULL };
-
- self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxMenuBar_SetLabel",_kwnames,&_argo0,&_arg1,&_obj2))
- return NULL;
- if (_argo0) {
- if (_argo0 == Py_None) { _arg0 = NULL; }
- else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMenuBar_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMenuBar_SetLabel. Expected _wxMenuBar_p.");
- return NULL;
- }
- }
-{
- if (!PyString_Check(_obj2)) {
- PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
- return NULL;
- }
- _arg2 = new wxString(PyString_AsString(_obj2), PyString_Size(_obj2));
-}
-{
- wxPy_BEGIN_ALLOW_THREADS;
- wxMenuBar_SetLabel(_arg0,_arg1,*_arg2);
-
- wxPy_END_ALLOW_THREADS;
-} Py_INCREF(Py_None);
- _resultobj = Py_None;
-{
- if (_obj2)
- delete _arg2;
-}
- return _resultobj;
-}
-
#define wxMenuBar_GetLabelTop(_swigobj,_swigarg0) (_swigobj->GetLabelTop(_swigarg0))
static PyObject *_wrap_wxMenuBar_GetLabelTop(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject * _resultobj;
{ "wxMenuBar_GetMenuCount", (PyCFunction) _wrap_wxMenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_SetLabelTop", (PyCFunction) _wrap_wxMenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_GetLabelTop", (PyCFunction) _wrap_wxMenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS },
- { "wxMenuBar_SetLabel", (PyCFunction) _wrap_wxMenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_SetHelpString", (PyCFunction) _wrap_wxMenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_GetLabel", (PyCFunction) _wrap_wxMenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_GetHelpString", (PyCFunction) _wrap_wxMenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_EnableTop", (PyCFunction) _wrap_wxMenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS },
+ { "wxMenuBar_SetLabel", (PyCFunction) _wrap_wxMenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_FindItemForId", (PyCFunction) _wrap_wxMenuBar_FindItemForId, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_FindMenuItem", (PyCFunction) _wrap_wxMenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS },
{ "wxMenuBar_Enabled", (PyCFunction) _wrap_wxMenuBar_Enabled, METH_VARARGS | METH_KEYWORDS },
{ "wxPanel_GetDefaultItem", (PyCFunction) _wrap_wxPanel_GetDefaultItem, METH_VARARGS | METH_KEYWORDS },
{ "wxPanel_InitDialog", (PyCFunction) _wrap_wxPanel_InitDialog, METH_VARARGS | METH_KEYWORDS },
{ "new_wxPanel", (PyCFunction) _wrap_new_wxPanel, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_SetValidator", (PyCFunction) _wrap_wxWindow_SetValidator, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_GetValidator", (PyCFunction) _wrap_wxWindow_GetValidator, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_SetSizer", (PyCFunction) _wrap_wxWindow_SetSizer, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_GetToolTip", (PyCFunction) _wrap_wxWindow_GetToolTip, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetToolTip", (PyCFunction) _wrap_wxWindow_SetToolTip, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetToolTipString", (PyCFunction) _wrap_wxWindow_SetToolTipString, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetId", (PyCFunction) _wrap_wxWindow_SetId, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetForegroundColour", (PyCFunction) _wrap_wxWindow_SetForegroundColour, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetFont", (PyCFunction) _wrap_wxWindow_SetFont, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_AcceptsFocus", (PyCFunction) _wrap_wxWindow_AcceptsFocus, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetFocus", (PyCFunction) _wrap_wxWindow_SetFocus, METH_VARARGS | METH_KEYWORDS },
+ { "wxWindow_UnsetConstraints", (PyCFunction) _wrap_wxWindow_UnsetConstraints, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetConstraints", (PyCFunction) _wrap_wxWindow_SetConstraints, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetBackgroundColour", (PyCFunction) _wrap_wxWindow_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_SetAutoLayout", (PyCFunction) _wrap_wxWindow_SetAutoLayout, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_Center", (PyCFunction) _wrap_wxWindow_Center, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_CaptureMouse", (PyCFunction) _wrap_wxWindow_CaptureMouse, METH_VARARGS | METH_KEYWORDS },
{ "new_wxWindow", (PyCFunction) _wrap_new_wxWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxPyValidator__setSelf", (PyCFunction) _wrap_wxPyValidator__setSelf, METH_VARARGS | METH_KEYWORDS },
+ { "wxPyValidator_Destroy", (PyCFunction) _wrap_wxPyValidator_Destroy, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxPyValidator", (PyCFunction) _wrap_new_wxPyValidator, METH_VARARGS | METH_KEYWORDS },
+ { "wxValidator_SetWindow", (PyCFunction) _wrap_wxValidator_SetWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxValidator_GetWindow", (PyCFunction) _wrap_wxValidator_GetWindow, METH_VARARGS | METH_KEYWORDS },
+ { "wxValidator_Clone", (PyCFunction) _wrap_wxValidator_Clone, METH_VARARGS | METH_KEYWORDS },
+ { "new_wxValidator", (PyCFunction) _wrap_new_wxValidator, METH_VARARGS | METH_KEYWORDS },
{ "wxEvtHandler_Connect", (PyCFunction) _wrap_wxEvtHandler_Connect, METH_VARARGS | METH_KEYWORDS },
+ { "wxEvtHandler_SetPreviousHandler", (PyCFunction) _wrap_wxEvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS },
+ { "wxEvtHandler_SetNextHandler", (PyCFunction) _wrap_wxEvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS },
+ { "wxEvtHandler_GetPreviousHandler", (PyCFunction) _wrap_wxEvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS },
+ { "wxEvtHandler_GetNextHandler", (PyCFunction) _wrap_wxEvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS },
+ { "wxEvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_wxEvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS },
+ { "wxEvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_wxEvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS },
{ "wxEvtHandler_ProcessEvent", (PyCFunction) _wrap_wxEvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_FromHWND", (PyCFunction) _wrap_wxWindow_FromHWND, METH_VARARGS | METH_KEYWORDS },
{ "wxWindow_FindFocus", (PyCFunction) _wrap_wxWindow_FindFocus, METH_VARARGS | METH_KEYWORDS },
+ { "wxValidator_SetBellOnError", (PyCFunction) _wrap_wxValidator_SetBellOnError, METH_VARARGS | METH_KEYWORDS },
+ { "wxValidator_IsSilent", (PyCFunction) _wrap_wxValidator_IsSilent, METH_VARARGS | METH_KEYWORDS },
{ NULL, NULL }
};
#ifdef __cplusplus
{ "_class_wxEvtHandler","_wxPanel",SwigwxPanelTowxEvtHandler},
{ "_class_wxEvtHandler","_class_wxWindow",SwigwxWindowTowxEvtHandler},
{ "_class_wxEvtHandler","_wxWindow",SwigwxWindowTowxEvtHandler},
+ { "_class_wxEvtHandler","_class_wxPyValidator",SwigwxPyValidatorTowxEvtHandler},
+ { "_class_wxEvtHandler","_wxPyValidator",SwigwxPyValidatorTowxEvtHandler},
+ { "_class_wxEvtHandler","_class_wxValidator",SwigwxValidatorTowxEvtHandler},
+ { "_class_wxEvtHandler","_wxValidator",SwigwxValidatorTowxEvtHandler},
{ "_class_wxEvtHandler","_wxEvtHandler",0},
{ "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
{ "_wxCursor","_class_wxCursor",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_wxRect","_class_wxRect",0},
{ "_wxPoint","_class_wxPoint",0},
{ "_wxBitmap","_class_wxBitmap",0},
{ "_wxPyTimer","_class_wxPyTimer",0},
{ "_wxWindowDC","_class_wxWindowDC",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
+ { "_class_wxValidator","_class_wxPyValidator",SwigwxPyValidatorTowxValidator},
+ { "_class_wxValidator","_wxPyValidator",SwigwxPyValidatorTowxValidator},
+ { "_class_wxValidator","_wxValidator",0},
{ "_EBool","_wxPrintQuality",0},
{ "_EBool","_signed_int",0},
{ "_EBool","_int",0},
{ "_class_wxWindow","_wxPanel",SwigwxPanelTowxWindow},
{ "_class_wxWindow","_wxWindow",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_class_wxPoint","_wxPoint",0},
{ "_wxRealPoint","_class_wxRealPoint",0},
{ "_wxRegionIterator","_class_wxRegionIterator",0},
{ "_class_wxPrinterDC","_wxPrinterDC",0},
{ "_class_wxPaintDC","_wxPaintDC",0},
+ { "_wxValidator","_class_wxPyValidator",SwigwxPyValidatorTowxValidator},
+ { "_wxValidator","_wxPyValidator",SwigwxPyValidatorTowxValidator},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_class_wxIcon","_wxIcon",0},
{ "_class_wxColour","_wxColour",0},
{ "_wxEvtHandler","_wxPanel",SwigwxPanelTowxEvtHandler},
{ "_wxEvtHandler","_class_wxWindow",SwigwxWindowTowxEvtHandler},
{ "_wxEvtHandler","_wxWindow",SwigwxWindowTowxEvtHandler},
+ { "_wxEvtHandler","_class_wxPyValidator",SwigwxPyValidatorTowxEvtHandler},
+ { "_wxEvtHandler","_wxPyValidator",SwigwxPyValidatorTowxEvtHandler},
+ { "_wxEvtHandler","_class_wxValidator",SwigwxValidatorTowxEvtHandler},
+ { "_wxEvtHandler","_wxValidator",SwigwxValidatorTowxEvtHandler},
{ "_wxEvtHandler","_class_wxEvtHandler",0},
{ "_wxMenuItem","_class_wxMenuItem",0},
{ "_wxDash","_unsigned_long",0},
def ProcessEvent(self, *_args, **_kwargs):
val = apply(windowsc.wxEvtHandler_ProcessEvent,(self,) + _args, _kwargs)
return val
+ def GetEvtHandlerEnabled(self, *_args, **_kwargs):
+ val = apply(windowsc.wxEvtHandler_GetEvtHandlerEnabled,(self,) + _args, _kwargs)
+ return val
+ def SetEvtHandlerEnabled(self, *_args, **_kwargs):
+ val = apply(windowsc.wxEvtHandler_SetEvtHandlerEnabled,(self,) + _args, _kwargs)
+ return val
+ def GetNextHandler(self, *_args, **_kwargs):
+ val = apply(windowsc.wxEvtHandler_GetNextHandler,(self,) + _args, _kwargs)
+ if val: val = wxEvtHandlerPtr(val)
+ return val
+ def GetPreviousHandler(self, *_args, **_kwargs):
+ val = apply(windowsc.wxEvtHandler_GetPreviousHandler,(self,) + _args, _kwargs)
+ if val: val = wxEvtHandlerPtr(val)
+ return val
+ def SetNextHandler(self, *_args, **_kwargs):
+ val = apply(windowsc.wxEvtHandler_SetNextHandler,(self,) + _args, _kwargs)
+ return val
+ def SetPreviousHandler(self, *_args, **_kwargs):
+ val = apply(windowsc.wxEvtHandler_SetPreviousHandler,(self,) + _args, _kwargs)
+ return val
def Connect(self, *_args, **_kwargs):
val = apply(windowsc.wxEvtHandler_Connect,(self,) + _args, _kwargs)
return val
+class wxValidatorPtr(wxEvtHandlerPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def Clone(self, *_args, **_kwargs):
+ val = apply(windowsc.wxValidator_Clone,(self,) + _args, _kwargs)
+ if val: val = wxValidatorPtr(val)
+ return val
+ def GetWindow(self, *_args, **_kwargs):
+ val = apply(windowsc.wxValidator_GetWindow,(self,) + _args, _kwargs)
+ if val: val = wxWindowPtr(val)
+ return val
+ def SetWindow(self, *_args, **_kwargs):
+ val = apply(windowsc.wxValidator_SetWindow,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxValidator instance at %s>" % (self.this,)
+class wxValidator(wxValidatorPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(windowsc.new_wxValidator,_args,_kwargs)
+ self.thisown = 1
+
+
+
+
+class wxPyValidatorPtr(wxValidatorPtr):
+ def __init__(self,this):
+ self.this = this
+ self.thisown = 0
+ def Destroy(self, *_args, **_kwargs):
+ val = apply(windowsc.wxPyValidator_Destroy,(self,) + _args, _kwargs)
+ return val
+ def _setSelf(self, *_args, **_kwargs):
+ val = apply(windowsc.wxPyValidator__setSelf,(self,) + _args, _kwargs)
+ return val
+ def __repr__(self):
+ return "<C wxPyValidator instance at %s>" % (self.this,)
+class wxPyValidator(wxPyValidatorPtr):
+ def __init__(self,*_args,**_kwargs):
+ self.this = apply(windowsc.new_wxPyValidator,_args,_kwargs)
+ self.thisown = 1
+ self._setSelf(self, 0)
+
+
+
+
class wxWindowPtr(wxEvtHandlerPtr):
def __init__(self,this):
self.this = this
def SetConstraints(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_SetConstraints,(self,) + _args, _kwargs)
return val
+ def UnsetConstraints(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_UnsetConstraints,(self,) + _args, _kwargs)
+ return val
def SetFocus(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_SetFocus,(self,) + _args, _kwargs)
return val
+ def AcceptsFocus(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_AcceptsFocus,(self,) + _args, _kwargs)
+ return val
def SetFont(self, *_args, **_kwargs):
val = apply(windowsc.wxWindow_SetFont,(self,) + _args, _kwargs)
return val
val = apply(windowsc.wxWindow_GetToolTip,(self,) + _args, _kwargs)
if val: val = wxToolTipPtr(val)
return val
+ def SetSizer(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_SetSizer,(self,) + _args, _kwargs)
+ return val
+ def GetValidator(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_GetValidator,(self,) + _args, _kwargs)
+ if val: val = wxValidatorPtr(val)
+ return val
+ def SetValidator(self, *_args, **_kwargs):
+ val = apply(windowsc.wxWindow_SetValidator,(self,) + _args, _kwargs)
+ return val
def __repr__(self):
return "<C wxWindow instance at %s>" % (self.this,)
class wxWindow(wxWindowPtr):
val = apply(windowsc.wxMenuBar_FindItemForId,(self,) + _args, _kwargs)
if val: val = wxMenuItemPtr(val)
return val
+ def SetLabel(self, *_args, **_kwargs):
+ val = apply(windowsc.wxMenuBar_SetLabel,(self,) + _args, _kwargs)
+ return val
def EnableTop(self, *_args, **_kwargs):
val = apply(windowsc.wxMenuBar_EnableTop,(self,) + _args, _kwargs)
return val
def SetHelpString(self, *_args, **_kwargs):
val = apply(windowsc.wxMenuBar_SetHelpString,(self,) + _args, _kwargs)
return val
- def SetLabel(self, *_args, **_kwargs):
- val = apply(windowsc.wxMenuBar_SetLabel,(self,) + _args, _kwargs)
- return val
def GetLabelTop(self, *_args, **_kwargs):
val = apply(windowsc.wxMenuBar_GetLabelTop,(self,) + _args, _kwargs)
return val
#-------------- FUNCTION WRAPPERS ------------------
+wxValidator_IsSilent = windowsc.wxValidator_IsSilent
+
+wxValidator_SetBellOnError = windowsc.wxValidator_SetBellOnError
+
def wxWindow_FindFocus(*_args, **_kwargs):
val = apply(windowsc.wxWindow_FindFocus,_args,_kwargs)
if val: val = wxWindowPtr(val)
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __cplusplus
extern "C" {
long _arg4 = (long ) 0;
char * _arg5 = (char *) "grid";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxGrid",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxGrid",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGrid. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxGrid. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxGrid *)new_wxGrid(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
long _arg4 = (long ) 0;
char * _arg5 = (char *) "notebook";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxNotebook",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxNotebook",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxNotebook. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxNotebook. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxNotebook *)new_wxNotebook(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
long _arg4 = (long ) wxSP_3D|wxCLIP_CHILDREN;
char * _arg5 = (char *) "splitterWindow";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","point","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxSplitterWindow",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxSplitterWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxSplitterWindow. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxSplitterWindow. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxSplitterWindow *)new_wxSplitterWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_class_wxSplitterEvent",SwigwxSplitterEventTowxEvent},
{ "_class_wxEvent","_wxSplitterEvent",SwigwxSplitterEventTowxEvent},
{ "_class_wxEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxEvent},
{ "_class_wxNotifyEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxNotifyEvent},
{ "_class_wxNotifyEvent","_wxNotebookEvent",SwigwxNotebookEventTowxNotifyEvent},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticBitmap","_wxStaticBitmap",0},
{ "_wxSplitterWindow","_class_wxSplitterWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxClientDC","_class_wxClientDC",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_wxSize","_class_wxSize",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_class_wxNotebook",SwigwxNotebookTowxControl},
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
#ifdef __cplusplus
extern "C" {
wxSashEvent * _arg0;
wxRect * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSashEvent_SetDragRect",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSashEvent_SetDragRect",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSashEvent_SetDragRect. Expected _wxRect_p.");
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSashEvent_SetDragRect(_arg0,*_arg1);
long _arg4 = (long ) wxCLIP_CHILDREN|(wxSW_3D);
char * _arg5 = (char *) "sashWindow";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxSashWindow",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxSashWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxSashWindow. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxSashWindow. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxSashWindow *)new_wxSashWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
wxQueryLayoutInfoEvent * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","size", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxQueryLayoutInfoEvent_SetSize",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxQueryLayoutInfoEvent_SetSize",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxQueryLayoutInfoEvent_SetSize. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxQueryLayoutInfoEvent_SetSize(_arg0,*_arg1);
wxCalculateLayoutEvent * _arg0;
wxRect * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxRect temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxCalculateLayoutEvent_SetRect",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxCalculateLayoutEvent_SetRect",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxCalculateLayoutEvent_SetRect. Expected _wxRect_p.");
+{
+ _arg1 = &temp;
+ if (! wxRect_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxCalculateLayoutEvent_SetRect(_arg0,*_arg1);
long _arg4 = (long ) wxCLIP_CHILDREN|(wxSW_3D);
char * _arg5 = (char *) "layoutWindow";
PyObject * _argo0 = 0;
- PyObject * _argo2 = 0;
- PyObject * _argo3 = 0;
+ wxPoint temp;
+ PyObject * _obj2 = 0;
+ wxSize temp0;
+ PyObject * _obj3 = 0;
char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
char _ptemp[128];
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxSashLayoutWindow",_kwnames,&_argo0,&_arg1,&_argo2,&_argo3,&_arg4,&_arg5))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxSashLayoutWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPoint_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxSashLayoutWindow. Expected _wxPoint_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxPoint_helper(_obj2, &_arg2))
return NULL;
- }
- }
- if (_argo3) {
- if (_argo3 == Py_None) { _arg3 = NULL; }
- else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxSashLayoutWindow. Expected _wxSize_p.");
+}
+ if (_obj3)
+{
+ _arg3 = &temp0;
+ if (! wxSize_helper(_obj3, &_arg3))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxSashLayoutWindow *)new_wxSashLayoutWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
wxSashLayoutWindow * _arg0;
wxSize * _arg1;
PyObject * _argo0 = 0;
- PyObject * _argo1 = 0;
+ wxSize temp;
+ PyObject * _obj1 = 0;
char *_kwnames[] = { "self","size", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSashLayoutWindow_SetDefaultSize",_kwnames,&_argo0,&_argo1))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxSashLayoutWindow_SetDefaultSize",_kwnames,&_argo0,&_obj1))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo1) {
- if (_argo1 == Py_None) { _arg1 = NULL; }
- else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxSize_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxSashLayoutWindow_SetDefaultSize. Expected _wxSize_p.");
+{
+ _arg1 = &temp;
+ if (! wxSize_helper(_obj1, &_arg1))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSashLayoutWindow_SetDefaultSize(_arg0,*_arg1);
wxRect * _arg2 = (wxRect *) NULL;
PyObject * _argo0 = 0;
PyObject * _argo1 = 0;
- PyObject * _argo2 = 0;
+ wxRect temp;
+ PyObject * _obj2 = 0;
char *_kwnames[] = { "self","frame","rect", NULL };
self = self;
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxLayoutAlgorithm_LayoutMDIFrame",_kwnames,&_argo0,&_argo1,&_argo2))
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|O:wxLayoutAlgorithm_LayoutMDIFrame",_kwnames,&_argo0,&_argo1,&_obj2))
return NULL;
if (_argo0) {
if (_argo0 == Py_None) { _arg0 = NULL; }
return NULL;
}
}
- if (_argo2) {
- if (_argo2 == Py_None) { _arg2 = NULL; }
- else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxRect_p")) {
- PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxLayoutAlgorithm_LayoutMDIFrame. Expected _wxRect_p.");
+ if (_obj2)
+{
+ _arg2 = &temp;
+ if (! wxRect_helper(_obj2, &_arg2))
return NULL;
- }
- }
+}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxLayoutAlgorithm_LayoutMDIFrame(_arg0,_arg1,_arg2);
{ "_class_wxActivateEvent","_wxActivateEvent",0},
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxPrintQuality","_int",0},
{ "_wxPrintQuality","_signed_int",0},
{ "_wxPrintQuality","_unsigned_int",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_class_wxCalculateLayoutEvent",SwigwxCalculateLayoutEventTowxEvent},
{ "_class_wxEvent","_wxCalculateLayoutEvent",SwigwxCalculateLayoutEventTowxEvent},
{ "_class_wxEvent","_class_wxQueryLayoutInfoEvent",SwigwxQueryLayoutInfoEventTowxEvent},
{ "_wxToolBarTool","_class_wxToolBarTool",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticBitmap","_wxStaticBitmap",0},
{ "_wxSplitterWindow","_class_wxSplitterWindow",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_wxSashEvent","_class_wxSashEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_wxButton","_class_wxButton",0},
{ "_wxSize","_class_wxSize",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxIconizeEvent","_class_wxIconizeEvent",0},
{ "_class_wxControl","_wxControl",0},
return target;
}
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-
static char* wxStringErrorMsg = "string type is required for parameter";
extern "C" SWIGEXPORT(void) initwindows3c();
extern "C" SWIGEXPORT(void) initimagec();
extern "C" SWIGEXPORT(void) initprintfwc();
+extern "C" SWIGEXPORT(void) initsizersc();
#ifdef __cplusplus
extern "C" {
#endif
{ "_signed_long","_long",0},
{ "_wxMenuEvent","_class_wxMenuEvent",0},
{ "_class_wxJPEGHandler","_wxJPEGHandler",0},
+ { "_class_wxPyCommandEvent","_wxPyCommandEvent",0},
{ "_wxBMPHandler","_class_wxBMPHandler",0},
{ "_wxImage","_class_wxImage",0},
{ "_wxPrintQuality","_int",0},
{ "_class_wxRegionIterator","_wxRegionIterator",0},
{ "_class_wxMenuBar","_wxMenuBar",0},
{ "_class_wxPyTreeItemData","_wxPyTreeItemData",0},
+ { "_class_wxStaticBoxSizer","_wxStaticBoxSizer",0},
{ "_class_wxEvtHandler","_class_wxPyApp",SwigwxPyAppTowxEvtHandler},
{ "_class_wxEvtHandler","_wxPyApp",SwigwxPyAppTowxEvtHandler},
{ "_class_wxEvtHandler","_wxEvtHandler",0},
{ "_wxPaintEvent","_class_wxPaintEvent",0},
{ "_wxGIFHandler","_class_wxGIFHandler",0},
+ { "_wxPySizer","_class_wxPySizer",0},
{ "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
{ "_wxCursor","_class_wxCursor",0},
{ "_wxNotifyEvent","_class_wxNotifyEvent",0},
{ "_wxDropFilesEvent","_class_wxDropFilesEvent",0},
{ "_wxBitmapButton","_class_wxBitmapButton",0},
{ "_wxSashWindow","_class_wxSashWindow",0},
+ { "_class_wxSizer","_wxSizer",0},
{ "_class_wxPrintDialogData","_wxPrintDialogData",0},
{ "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
{ "_class_wxGauge","_wxGauge",0},
{ "_class_wxSashEvent","_wxSashEvent",0},
{ "_wxDC","_class_wxDC",0},
+ { "_wxSizerItem","_class_wxSizerItem",0},
{ "_wxListEvent","_class_wxListEvent",0},
{ "_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0},
{ "_wxProgressDialog","_class_wxProgressDialog",0},
{ "_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0},
{ "_class_wxStatusBar","_wxStatusBar",0},
{ "_class_wxGIFHandler","_wxGIFHandler",0},
+ { "_class_wxPySizer","_wxPySizer",0},
{ "_wxPanel","_class_wxPanel",0},
{ "_wxInitDialogEvent","_class_wxInitDialogEvent",0},
{ "_wxCheckBox","_class_wxCheckBox",0},
{ "_uint","_unsigned_int",0},
{ "_uint","_int",0},
{ "_uint","_wxWindowID",0},
+ { "_wxPyValidator","_class_wxPyValidator",0},
{ "_class_wxEvent","_wxEvent",0},
{ "_wxCheckListBox","_class_wxCheckListBox",0},
{ "_wxSplitterEvent","_class_wxSplitterEvent",0},
{ "_class_wxButton","_wxButton",0},
{ "_wxRadioBox","_class_wxRadioBox",0},
{ "_class_wxFontData","_wxFontData",0},
+ { "_wxBoxSizer","_class_wxBoxSizer",0},
{ "_class___wxPyCleanup","___wxPyCleanup",0},
{ "_wxBitmap","_class_wxBitmap",0},
{ "_wxTaskBarIcon","_class_wxTaskBarIcon",0},
{ "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
{ "_class_wxNotifyEvent","_wxNotifyEvent",0},
{ "_wxMessageDialog","_class_wxMessageDialog",0},
+ { "_class_wxValidator","_wxValidator",0},
{ "_class_wxPyEvent","_wxPyEvent",0},
{ "_wxTextEntryDialog","_class_wxTextEntryDialog",0},
{ "_class_wxIconizeEvent","_wxIconizeEvent",0},
{ "_class_wxStaticText","_wxStaticText",0},
{ "_wxPrintDialogData","_class_wxPrintDialogData",0},
{ "_class_wxFont","_wxFont",0},
+ { "_class_wxPyValidator","_wxPyValidator",0},
{ "_class_wxCloseEvent","_wxCloseEvent",0},
{ "_wxSashEvent","_class_wxSashEvent",0},
{ "_class_wxMenuEvent","_wxMenuEvent",0},
{ "_wxRealPoint","_class_wxRealPoint",0},
{ "_class_wxRadioBox","_wxRadioBox",0},
{ "_wxGridCell","_class_wxGridCell",0},
+ { "_class_wxBoxSizer","_wxBoxSizer",0},
{ "_signed_short","_WXTYPE",0},
{ "_signed_short","_short",0},
{ "_wxMemoryDC","_class_wxMemoryDC",0},
{ "_wxWindowID","_signed_int",0},
{ "_wxWindowID","_unsigned_int",0},
{ "_class_wxScrollWinEvent","_wxScrollWinEvent",0},
+ { "_class_wxSizerItem","_wxSizerItem",0},
{ "_int","_wxPrintQuality",0},
{ "_int","_size_t",0},
{ "_int","_EBool",0},
{ "_int","_unsigned_int",0},
{ "_int","_signed_int",0},
{ "_class_wxMouseEvent","_wxMouseEvent",0},
+ { "_wxPyCommandEvent","_class_wxPyCommandEvent",0},
{ "_class_wxListEvent","_wxListEvent",0},
{ "_class_wxPrintPreview","_wxPrintPreview",0},
{ "_class_wxSpinEvent","_wxSpinEvent",0},
{ "_class_wxPrinterDC","_wxPrinterDC",0},
{ "_class_wxMDIParentFrame","_wxMDIParentFrame",0},
{ "_wxPyTreeItemData","_class_wxPyTreeItemData",0},
+ { "_wxStaticBoxSizer","_class_wxStaticBoxSizer",0},
{ "_class_wxPaintDC","_wxPaintDC",0},
{ "_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0},
{ "_class_wxInitDialogEvent","_wxInitDialogEvent",0},
{ "_class_wxComboBox","_wxComboBox",0},
{ "_class_wxRadioButton","_wxRadioButton",0},
+ { "_wxValidator","_class_wxValidator",0},
{ "_class_wxTreeItemId","_wxTreeItemId",0},
{ "_wxTreeCtrl","_class_wxTreeCtrl",0},
{ "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
{ "_wxRegion","_class_wxRegion",0},
{ "_class_wxSplitterWindow","_wxSplitterWindow",0},
{ "_wxPreviewFrame","_class_wxPreviewFrame",0},
+ { "_wxSizer","_class_wxSizer",0},
{ "_class_wxShowEvent","_wxShowEvent",0},
{ "_wxActivateEvent","_class_wxActivateEvent",0},
{ "_wxGauge","_class_wxGauge",0},
PyDict_SetItemString(d,"wxALIGN_CENTER", PyInt_FromLong((long) wxALIGN_CENTER));
PyDict_SetItemString(d,"wxALIGN_CENTRE", PyInt_FromLong((long) wxALIGN_CENTRE));
PyDict_SetItemString(d,"wxALIGN_RIGHT", PyInt_FromLong((long) wxALIGN_RIGHT));
+ PyDict_SetItemString(d,"wxALIGN_BOTTOM", PyInt_FromLong((long) wxALIGN_BOTTOM));
+ PyDict_SetItemString(d,"wxALIGN_TOP", PyInt_FromLong((long) wxALIGN_TOP));
PyDict_SetItemString(d,"wxLB_NEEDED_SB", PyInt_FromLong((long) wxLB_NEEDED_SB));
PyDict_SetItemString(d,"wxLB_ALWAYS_SB", PyInt_FromLong((long) wxLB_ALWAYS_SB));
PyDict_SetItemString(d,"wxLB_SORT", PyInt_FromLong((long) wxLB_SORT));
PyDict_SetItemString(d,"wxEVT_COMMAND_LIST_INSERT_ITEM", PyInt_FromLong((long) wxEVT_COMMAND_LIST_INSERT_ITEM));
PyDict_SetItemString(d,"wxEVT_COMMAND_LIST_COL_CLICK", PyInt_FromLong((long) wxEVT_COMMAND_LIST_COL_CLICK));
PyDict_SetItemString(d,"wxEVT_COMMAND_LIST_ITEM_ACTIVATED", PyInt_FromLong((long) wxEVT_COMMAND_LIST_ITEM_ACTIVATED));
+ PyDict_SetItemString(d,"wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK", PyInt_FromLong((long) wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK));
+ PyDict_SetItemString(d,"wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK", PyInt_FromLong((long) wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK));
PyDict_SetItemString(d,"wxEVT_COMMAND_TAB_SEL_CHANGED", PyInt_FromLong((long) wxEVT_COMMAND_TAB_SEL_CHANGED));
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_SPLITTER_SASH_POS_CHANGED", PyInt_FromLong((long) wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED));
PyDict_SetItemString(d,"wxEVT_COMMAND_SPLITTER_UNSPLIT", PyInt_FromLong((long) wxEVT_COMMAND_SPLITTER_UNSPLIT));
PyDict_SetItemString(d,"wxEVT_COMMAND_SPLITTER_DOUBLECLICKED", PyInt_FromLong((long) wxEVT_COMMAND_SPLITTER_DOUBLECLICKED));
- PyDict_SetItemString(d,"__version__", PyString_FromString("2.1b4"));
+ PyDict_SetItemString(d,"wxEVT_NAVIGATION_KEY", PyInt_FromLong((long) wxEVT_NAVIGATION_KEY));
+ PyDict_SetItemString(d,"__version__", PyString_FromString("0.0.0"));
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);
initwindows3c();
initimagec();
initprintfwc();
+ initsizersc();
{
int i;
for (i = 0; _swig_mapping[i].n1; i++)
from image import *
from printfw import *
+
+from sizers import *
class wxPyAppPtr(wxEvtHandlerPtr):
def __init__(self,this):
self.this = this
wxALIGN_CENTER = wxc.wxALIGN_CENTER
wxALIGN_CENTRE = wxc.wxALIGN_CENTRE
wxALIGN_RIGHT = wxc.wxALIGN_RIGHT
+wxALIGN_BOTTOM = wxc.wxALIGN_BOTTOM
+wxALIGN_TOP = wxc.wxALIGN_TOP
wxLB_NEEDED_SB = wxc.wxLB_NEEDED_SB
wxLB_ALWAYS_SB = wxc.wxLB_ALWAYS_SB
wxLB_SORT = wxc.wxLB_SORT
wxEVT_COMMAND_LIST_INSERT_ITEM = wxc.wxEVT_COMMAND_LIST_INSERT_ITEM
wxEVT_COMMAND_LIST_COL_CLICK = wxc.wxEVT_COMMAND_LIST_COL_CLICK
wxEVT_COMMAND_LIST_ITEM_ACTIVATED = wxc.wxEVT_COMMAND_LIST_ITEM_ACTIVATED
+wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK = wxc.wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
+wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK = wxc.wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
wxEVT_COMMAND_TAB_SEL_CHANGED = wxc.wxEVT_COMMAND_TAB_SEL_CHANGED
wxEVT_COMMAND_TAB_SEL_CHANGING = wxc.wxEVT_COMMAND_TAB_SEL_CHANGING
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED = wxc.wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED = wxc.wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED
wxEVT_COMMAND_SPLITTER_UNSPLIT = wxc.wxEVT_COMMAND_SPLITTER_UNSPLIT
wxEVT_COMMAND_SPLITTER_DOUBLECLICKED = wxc.wxEVT_COMMAND_SPLITTER_DOUBLECLICKED
+wxEVT_NAVIGATION_KEY = wxc.wxEVT_NAVIGATION_KEY
__version__ = wxc.__version__
cvar = wxc.cvar
wxPyDefaultPosition = wxPointPtr(wxc.cvar.wxPyDefaultPosition)
def EVT_LIST_COL_CLICK(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_COL_CLICK, func)
+def EVT_LIST_ITEM_RIGHT_CLICK(win, id, func):
+ win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, func)
+
+def EVT_LIST_ITEM_MIDDLE_CLICK(win, id, func):
+ win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK, func)
+
+
+
#wxSplitterWindow
def EVT_SPLITTER_SASH_POS_CHANGING(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING, func)
wxPyDefaultSize.Set(-1,-1)
# aliases so that C++ documentation applies:
-wxDefaultPosition = wxPyDefaultPosition
-wxDefaultSize = wxPyDefaultSize
-
+wxDefaultPosition = wxPyDefaultPosition
+wxDefaultSize = wxPyDefaultSize
-# This is to cover up a bug in SWIG. We are redefining
-# the shadow class that is generated for wxAcceleratorTable
-# because SWIG incorrectly uses "arg0.this"
-class wxAcceleratorTable(wxAcceleratorTablePtr):
- def __init__(self,arg0) :
- self.this = miscc.new_wxAcceleratorTable(arg0)
- self.thisown = 1
#----------------------------------------------------------------------
# This helper function will take a wxPython object and convert it to
#----------------------------------------------------------------------
-## class wxPyStdOutWindow:
-## def __init__(self, title = "wxPython: stdout/stderr"):
-## self.frame = None
-## self.title = title
+class wxPyOnDemandOutputWindow:
+ def __init__(self, title = "wxPython: stdout/stderr"):
+ self.frame = None
+ self.title = title
-## 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 SetParent(self, parent):
+ self.parent = parent
-## def OnCloseWindow(self, event):
-## wxBell()
-## self.frame.Destroy()
-## self.frame = None
-## self.text = None
+ def OnCloseWindow(self, event):
+ if self.frame != None:
+ self.frame.Destroy()
+ self.frame = None
+ self.text = None
+
+ # this provides the file-like behaviour
+ def write(self, str):
+ if not self.frame:
+ self.frame = wxFrame(self.parent, -1, self.title)
+ self.text = wxTextCtrl(self.frame, -1, "",
+ style = 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 close(self):
+ self.frame = None
+ self.text = None
-## def close(self):
-## if self.frame:
-## self.frame.Close(true)
_defRedirect = (wxPlatform == '__WXMSW__')
class wxApp(wxPyApp):
error = 'wxApp.error'
+ outputWindowClass = wxPyOnDemandOutputWindow
def __init__(self, redirect=_defRedirect, filename=None):
wxPyApp.__init__(self)
self.saveStdio = (sys.stdout, sys.stderr)
if redirect:
self.RedirectStdio(filename)
-
# this initializes wxWindows and then calls our OnInit
_wxStart(self.OnInit)
except:
pass
+
+ def SetTopWindow(self, frame):
+ if self.stdioWin:
+ self.stdioWin.SetParent(frame)
+ sys.stdout = self.stdioWin #sys.stderr =
+ wxPyApp.SetTopWindow(self, frame)
+
+ def MainLoop(self):
+ wxPyApp.MainLoop(self)
+ self.RestoreStdio()
+
def RedirectStdio(self, filename):
if filename:
sys.stdout = sys.stderr = open(filename, 'a')
else:
- raise self.error, 'wxPyStdOutWindow not yet implemented.'
- #self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow()
+ self.stdioWin = self.outputWindowClass() # wxPyOnDemandOutputWindow
def RestoreStdio(self):
sys.stdout, sys.stderr = self.saveStdio
self.stdioWin.close()
+
#----------------------------------------------------------------------------
# DO NOT hold any other references to this object. This is how we know when
# to cleanup system resources that wxWin is holding...
}
//----------------------------------------------------------------------
-// Here are some to map (int LCOUNT, int* LIST), etc. from a python list
-
-%{
-
-HELPEREXPORT byte* byte_LIST_helper(PyObject* source);
-HELPEREXPORT int* int_LIST_helper(PyObject* source);
-HELPEREXPORT long* long_LIST_helper(PyObject* source);
-HELPEREXPORT char** string_LIST_helper(PyObject* source);
-HELPEREXPORT wxPoint* wxPoint_LIST_helper(PyObject* source);
-HELPEREXPORT wxBitmap** wxBitmap_LIST_helper(PyObject* source);
-HELPEREXPORT wxString* wxString_LIST_helper(PyObject* source);
-HELPEREXPORT wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
-
-%}
-
-//----------------------------------------------------------------------
+// LCOUNT and LIST go together. They allow a single Python list to be
+// converted to an integer count and an array count items long.
%typemap(python,build) int LCOUNT {
if (_in_LIST) {
}
-// --------------------------------------------------------------------
+
+
+
//---------------------------------------------------------------------------
+// Typemaps to convert Python sequence objects (2-tuples, etc.) to
+// wxSize, wxPoint, wxRealPoint, and wxRect.
+
+%typemap(python,in) wxSize& (wxSize temp) {
+ $target = &temp;
+ if (! wxSize_helper($source, &$target))
+ return NULL;
+}
+
+%typemap(python,in) wxPoint& (wxPoint temp) {
+ $target = &temp;
+ if (! wxPoint_helper($source, &$target))
+ return NULL;
+}
+
+%typemap(python,in) wxRealPoint& (wxRealPoint temp) {
+ $target = &temp;
+ if (! wxRealPoint_helper($source, &$target))
+ return NULL;
+}
+%typemap(python,in) wxRect& (wxRect temp) {
+ $target = &temp;
+ if (! wxRect_helper($source, &$target))
+ return NULL;
+}
-// --------------------------------------------------------------------
+//---------------------------------------------------------------------------
// Map T_OUTPUTs for floats to return ints.
}
//---------------------------------------------------------------------------
-/////////////////////////////////////////////////////////////////////////////
-//
-// $Log$
-// Revision 1.6 1999/09/10 06:05:32 RD
-// Lots more support for event-less callbacks
-// Exported some symbols for the other modules to use
-// etc.
-//
-// 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
-//
-// Revision 1.3 1998/11/15 23:03:47 RD
-// Removing some ifdef's for wxGTK
-//
-// Revision 1.2 1998/08/14 23:36:39 RD
-// Beginings of wxGTK compatibility
-//
-// Revision 1.1 1998/08/09 08:25:52 RD
-// Initial version
-//
-//
+//---------------------------------------------------------------------------
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: sizers.i
+// Purpose: SWIG definitions of the wxSizer family of classes
+//
+// Author: Robin Dunn
+//
+// Created: 18-Sept-1999
+// RCS-ID: $Id$
+// Copyright: (c) 1998 by Total Control Software
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module sizers
+
+%{
+#include "helpers.h"
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import windows.i
+%import controls.i
+
+%pragma(python) code = "import wx"
+%pragma(python) code = "import string"
+
+//---------------------------------------------------------------------------
+
+%{
+class wxPyUserData : public wxObject {
+public:
+ wxPyUserData(PyObject* obj) { m_obj = obj; Py_INCREF(m_obj); }
+ ~wxPyUserData() {
+ bool doSave = wxPyRestoreThread();
+ Py_DECREF(m_obj);
+ wxPySaveThread(doSave);
+ }
+ PyObject* m_obj;
+};
+%}
+
+//---------------------------------------------------------------------------
+
+class wxSizerItem {
+public:
+ // No need to ever create one directly in Python...
+
+ //wxSizerItem( int width, int height, int option, int flag, int border, wxObject* userData);
+ //wxSizerItem( wxWindow *window, int option, int flag, int border, wxObject* userData );
+ //wxSizerItem( wxSizer *sizer, int option, int flag, int border, wxObject* userData );
+
+ wxSize GetSize();
+ wxSize CalcMin();
+ void SetDimension( wxPoint pos, wxSize size );
+
+ bool IsWindow();
+ bool IsSizer();
+ bool IsSpacer();
+
+ wxWindow *GetWindow();
+ wxSizer *GetSizer();
+ int GetOption();
+ int GetFlag();
+ int GetBorder();
+
+ // wxObject* GetUserData();
+ %addmethods {
+ // Assume that the user data is a wxPyUserData object and return the contents
+ PyObject* GetUserData() {
+ wxPyUserData* data = (wxPyUserData*)self->GetUserData();
+ if (data) {
+ Py_INCREF(data->m_obj);
+ return data->m_obj;
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ }
+ }
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxSizer {
+public:
+ // wxSizer(); **** abstract, can't instantiate
+ // ~wxSizer();
+
+ %addmethods {
+ void Destroy() { delete self; }
+
+ void AddWindow(wxWindow *window, int option=0, int flag=0, int border=0,
+ PyObject* userData=NULL) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Add(window, option, flag, border, data);
+ }
+
+ void AddSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
+ PyObject* userData=NULL) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Add(sizer, option, flag, border, data);
+ }
+
+ void AddSpacer(int width, int height, int option=0, int flag=0,
+ int border=0, PyObject* userData=NULL) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Add(width, height, option, flag, border, data);
+ }
+
+
+ void PrependWindow(wxWindow *window, int option=0, int flag=0, int border=0,
+ PyObject* userData=NULL) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Prepend(window, option, flag, border, data);
+ }
+
+ void PrependSizer(wxSizer *sizer, int option=0, int flag=0, int border=0,
+ PyObject* userData=NULL) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Prepend(sizer, option, flag, border, data);
+ }
+
+ void PrependSpacer(int width, int height, int option=0, int flag=0,
+ int border=0, PyObject* userData=NULL) {
+ wxPyUserData* data = NULL;
+ if (userData) data = new wxPyUserData(userData);
+ self->Prepend(width, height, option, flag, border, data);
+ }
+ }
+
+ %name(RemoveWindow)bool Remove( wxWindow *window );
+ %name(RemoveSizer)bool Remove( wxSizer *sizer );
+ %name(RemovePos)bool Remove( int pos );
+
+
+ %pragma(python) addtoclass = "
+ def Add(self, *args):
+ if type(args[0]) == type(1):
+ apply(self.AddSpacer, args)
+ elif string.find(args[0].this, 'Sizer') != -1:
+ apply(self.AddSizer, args)
+ else:
+ apply(self.AddWindow, args)
+
+ def Prepend(self, *args):
+ if type(args[0]) == type(1):
+ apply(self.PrependSpacer, args)
+ elif string.find(args[0].this, 'Sizer') != -1:
+ apply(self.PrependSizer, args)
+ else:
+ apply(self.PrependWindow, args)
+
+ def Remove(self, *args):
+ if type(args[0]) == type(1):
+ apply(self.RemovePos, args)
+ elif string.find(args[0].this, 'Sizer') != -1:
+ apply(self.RemoveSizer, args)
+ else:
+ apply(self.RemoveWindow, args)
+
+ def AddMany(self, widgets):
+ for childinfo in widgets:
+ if type(childinfo) != type(()):
+ childinfo = (childinfo, )
+ apply(self.Add, childinfo)
+"
+
+
+ void SetDimension( int x, int y, int width, int height );
+
+ wxSize GetSize();
+ wxPoint GetPosition();
+ wxSize GetMinSize();
+
+ // void RecalcSizes() = 0;
+ // wxSize CalcMin() = 0;
+
+ void Layout();
+
+ void Fit( wxWindow *window );
+ void SetSizeHints( wxWindow *window );
+
+ // wxList& GetChildren();
+ %addmethods {
+ PyObject* GetChildren() {
+ wxList& list = self->GetChildren();
+ return wxPy_ConvertList(&list, "wxSizerItem");
+ }
+ }
+};
+
+
+//---------------------------------------------------------------------------
+// Use this one for deriving Python classes from
+%{
+class wxPySizer : public wxSizer {
+ DECLARE_DYNAMIC_CLASS(wxPySizer);
+public:
+ wxPySizer() : wxSizer() {};
+
+ DEC_PYCALLBACK___pure(RecalcSizes);
+ DEC_PYCALLBACK_wxSize__pure(CalcMin);
+ PYPRIVATE;
+};
+
+
+IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
+IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
+
+IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
+%}
+
+
+
+class wxPySizer : public wxSizer {
+public:
+ wxPySizer();
+ void _setSelf(PyObject* self);
+ %pragma(python) addtomethod = "__init__:self._setSelf(self)"
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxBoxSizer : public wxSizer {
+public:
+ wxBoxSizer(int orient = wxHORIZONTAL);
+ int GetOrientation();
+};
+
+//---------------------------------------------------------------------------
+
+class wxStaticBoxSizer : public wxBoxSizer {
+public:
+ wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
+ wxStaticBox *GetStaticBox();
+};
+
+//---------------------------------------------------------------------------
%import misc.i
%import gdi.i
-%pragma(python) code = "import wx"
+%pragma(python) code = "import wx"
//---------------------------------------------------------------------------
class wxEvtHandler {
public:
bool ProcessEvent(wxEvent& event);
+ //bool SearchEventTable(wxEventTable& table, wxEvent& event);
+
+ bool GetEvtHandlerEnabled();
+ void SetEvtHandlerEnabled(bool enabled);
+
+ wxEvtHandler* GetNextHandler();
+ wxEvtHandler* GetPreviousHandler();
+ void SetNextHandler(wxEvtHandler* handler);
+ void SetPreviousHandler(wxEvtHandler* handler);
+
+
%addmethods {
void Connect( int id, int lastId, int eventType, PyObject* func) {
if (PyCallable_Check(func)) {
};
+//----------------------------------------------------------------------
+
+class wxValidator : public wxEvtHandler {
+public:
+ wxValidator();
+ //~wxValidator();
+
+ wxValidator* Clone();
+ wxWindow* GetWindow();
+ void SetWindow(wxWindow* window);
+};
+
+%inline %{
+ bool wxValidator_IsSilent() {
+ return wxValidator::IsSilent();
+ }
+
+ void wxValidator_SetBellOnError(int doIt = TRUE) {
+ wxValidator::SetBellOnError(doIt);
+ }
+%}
+
+//----------------------------------------------------------------------
+%{
+class wxPyValidator : public wxValidator {
+ DECLARE_DYNAMIC_CLASS(wxPyValidator);
+public:
+ wxPyValidator() {
+ }
+// wxPyValidator(const wxPyValidator& other);
+
+ ~wxPyValidator() {
+ }
+
+ wxObject* wxPyValidator::Clone() const {
+ wxPyValidator* ptr = NULL;
+ wxPyValidator* self = (wxPyValidator*)this;
+
+ bool doSave = wxPyRestoreThread();
+ if (self->m_myInst.findCallback("Clone")) {
+ PyObject* ro;
+ ro = self->m_myInst.callCallbackObj(Py_BuildValue("()"));
+ SWIG_GetPtrObj(ro, (void **)&ptr, "_wxPyValidator_p");
+ }
+ // This is very dangerous!!! But is the only way I could find
+ // to squash a memory leak. Currently it is okay, but if the
+ // validator architecture in wxWindows ever changes, problems
+ // could arise.
+ delete self;
+
+ wxPySaveThread(doSave);
+ return ptr;
+}
+
+
+ DEC_PYCALLBACK_BOOL_WXWIN(Validate);
+ DEC_PYCALLBACK_BOOL_(TransferToWindow);
+ DEC_PYCALLBACK_BOOL_(TransferFromWindow);
+
+ PYPRIVATE;
+// PyObject* m_data;
+};
+
+IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
+IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
+IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
+
+IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
+
+%}
+
+class wxPyValidator : public wxValidator {
+public:
+ wxPyValidator();
+// ~wxPyValidator();
+
+ %addmethods {
+ void Destroy() { delete self; }
+ }
+
+ void _setSelf(PyObject* self, int incref=TRUE);
+ %pragma(python) addtomethod = "__init__:self._setSelf(self, 0)"
+
+};
+
//----------------------------------------------------------------------
%apply int * INOUT { int* x, int* y };
void SetAutoLayout(bool autoLayout);
void SetBackgroundColour(const wxColour& colour);
void SetConstraints(wxLayoutConstraints *constraints);
+ void UnsetConstraints(wxLayoutConstraints *constraints);
void SetFocus();
+ bool AcceptsFocus();
void SetFont(const wxFont& font);
void SetForegroundColour(const wxColour& colour);
void SetId(int id);
%name(SetToolTipString)void SetToolTip(const wxString &tip);
void SetToolTip(wxToolTip *tooltip);
wxToolTip* GetToolTip();
+
+ void SetSizer(wxSizer* sizer);
+ wxValidator* GetValidator();
+ void SetValidator(const wxValidator& validator);
+
};
//%clear int* x, int* y;
%import windows3.i
%import image.i
%import printfw.i
+%import sizers.i
%native(_wxStart) __wxStart;
//---------------------------------------------------------------------------
-#define __version__ "2.1b4"
+
+#define __version__ "0.0.0" // The real value is in build.py...
wxPoint wxPyDefaultPosition;
wxSize wxPyDefaultSize;
};
-
//----------------------------------------------------------------------
// This code gets added to the module initialization function
//----------------------------------------------------------------------
extern "C" SWIGEXPORT(void) initwindows3c();
extern "C" SWIGEXPORT(void) initimagec();
extern "C" SWIGEXPORT(void) initprintfwc();
+extern "C" SWIGEXPORT(void) initsizersc();
%}
initwindows3c();
initimagec();
initprintfwc();
+ initsizersc();
%}
//----------------------------------------------------------------------
#---------------------------------------------------------------------------
-app = MyApp(0) # Create an instance of the application class
+app = MyApp(1) # Create an instance of the application class
app.MainLoop() # Tell it to start processing events
print 'done!'
projects / wxWidgets.git / commitdiff
