AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wxPython 2.1b1 for wxMSW (wxGTK coming soon)

Browse Source 
Lots of changes, see the README.txt for details...


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2857 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn 1999-06-22 07:03:29 +00:00
parent 2233e5b82c
commit bb0054cda8
71 changed files with 9629 additions and 4102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
utils/wxPython/.cvsignore
View File

@ -1,6 +1,7 @@
*.zip
*.pyc
*.pyd
*.pyo
*.zip
.cvsignore
.emacs.desktop
__init__.py
@ -48,6 +49,8 @@ gdi.pyo
gdi.pyo
glcanvas.py
glcanvas.pyc
glcanvasc.ilk
glcanvasc.pyd
image.py
image.pyc
mdi.py
@ -62,6 +65,7 @@ misc.pyc
misc.pyc
misc.pyo
misc.pyo
printfw.py
stattool.py
stattool.py
stattool.pyc
@ -104,3 +108,7 @@ wxp.pyo
wxpc.ilk
wxpc.pdb
wxpc.pyd
*.py
*.pyc
*.pyo
*.pyd

40
utils/wxPython/README.txt
View File

@ -3,7 +3,7 @@ wxPython README
Welcome to the wonderful world of wxPython!
Now that you have installed the Win32 extension module, you can try it
Once you have installed the wxPython extension module, you can try it
out by going to the [install dir]\wxPython\demo directory and typing:
python demo.py
@ -17,6 +17,14 @@ at the docs for wxWindows. For the most part you can use the C++ docs
as most classes and methods are used identically. Where there are
differences they are documented with a "wxPython Note."
On Win32 systems the binary self-installer creates a program group on
the Start Menu that contains a link to running the demo and a link to
the help file. To help you save disk space I'm now using Microsoft's
HTML Help format. If your system doesn't know what to do with the help
file, you can install the HTML Help Viewer as part of IE 4+, NT
Service Pack 4+, or the HTML Workshop at
http://msdn.microsoft.com/workshop/author/htmlhelp/download.asp.
Getting Help
@ -34,6 +42,34 @@ Or you can send mail directly to the list using this address:
wxpython-users@starship.python.net
----------------------------------------------------------------------
What's new in 2.1b1
--------------------
Fixed wxComboBox.SetSelection so that it actually sets the selected
item. (Actually just removed it from wxPython and let it default to
wxChoice.SetSelection which was already doing the right thing.)
Added the Printing Framework.
Switched back to using the wxWindows DLL for the pre-built Win32
version. The problem was needing to reinitialize static class info
data after loading each extension module.
Lots of little tweaks and additions to reflect changes to various
wxWindows classes.
Fixed a bug with attaching objects to tree items. Actually was a
symptom of a larger problem with not obtaining the interpreter lock
when doing any Py_DECREFs.
wxSizer and friends. Sizers are layout tools that manage a colection
of windows and sizers. Different types of sizers apply different
types of layout algorithms. You saw it here first! These classes are
not even in the wxWindows C++ library yet!
What's new in 2.0b9
-------------------
@ -162,7 +198,6 @@ down a nasty DECREF bug. Okay so I have to confess that it was just a
DSM (Dumb Stupid Mistake) on my part but it was nasty none the less
because the behavior was so different on different platforms.
The dynamicly loaded module on Solaris is still segfaulting, so it
must have been a different issue all along...
@ -182,6 +217,7 @@ version segfault shortly after starting up.
3. Varioius bug fixes, enhancements, etc.
----------------------------------------------------------------------

4
utils/wxPython/demo/DialogUnits.py
View File

@ -35,14 +35,14 @@ class MyFrame(wxFrame):
wxStaticText(panel, -1, "Size:",
wxDLG_PNT(panel, wxPoint(4, 4)), wxDefaultSize)
wxStaticText(panel, -1, "Pos:",
wxDLG_PNT(panel, wxPoint(4, 14)), wxDefaultSize)
wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
self.sizeCtrl = wxTextCtrl(panel, -1, "",
wxDLG_PNT(panel, wxPoint(24, 4)),
wxDLG_SZE(panel, wxSize(36, -1)),
wxTE_READONLY)
self.posCtrl = wxTextCtrl(panel, -1, "",
wxDLG_PNT(panel, wxPoint(24, 14)),
wxDLG_PNT(panel, wxPoint(24, 16)),
wxDLG_SZE(panel, wxSize(36, -1)),
wxTE_READONLY)

39
utils/wxPython/demo/Main.py
View File

@ -28,18 +28,19 @@ _treeList = [
('Common Dialogs', ['wxColourDialog', 'wxDirDialog', 'wxFileDialog',
'wxSingleChoiceDialog', 'wxTextEntryDialog',
'wxFontDialog', 'wxPageSetupDialog', 'wxPrintDialog',
'wxMessageDialog']),
'wxMessageDialog', 'wxProgressDialog']),
('Controls', ['wxButton', 'wxCheckBox', 'wxCheckListBox', 'wxChoice',
'wxComboBox', 'wxGauge', 'wxListBox', 'wxListCtrl', 'wxTextCtrl',
'wxTreeCtrl', 'wxSpinButton', 'wxStaticText', 'wxStaticBitmap',
'wxRadioBox', 'wxSlider']),
('Window Layout', ['wxLayoutConstraints']),
('Window Layout', ['wxLayoutConstraints', 'Sizers']),
('Micellaneous', ['wxTimer', 'wxGLCanvas', 'DialogUnits', 'wxImage']),
('Miscellaneous', ['wxTimer', 'wxGLCanvas', 'DialogUnits', 'wxImage',
'PrintFramework']),
('wxPython Library', ['Layoutf', 'wxScrolledMessageDialog',
('wxPython Library', ['Sizers', 'Layoutf', 'wxScrolledMessageDialog',
'wxMultipleChoiceDialog', 'wxPlotCanvas']),
('Cool Contribs', ['pyTree', 'hangman', 'SlashDot']),
@ -83,6 +84,11 @@ class wxPythonDemo(wxFrame):
self.mainmenu.Append(menu, '&Help')
self.SetMenuBar(self.mainmenu)
selectedDemo = None
selectedDemoName = "Nada"
if len(sys.argv) == 2:
selectedDemoName = sys.argv[1]
# Create a TreeCtrl
tID = NewId()
self.tree = wxTreeCtrl(splitter, tID)
@ -90,13 +96,15 @@ class wxPythonDemo(wxFrame):
for item in _treeList:
child = self.tree.AppendItem(root, item[0])
for childItem in item[1]:
self.tree.AppendItem(child, childItem)
theDemo = self.tree.AppendItem(child, childItem)
if childItem == selectedDemoName:
selectedDemo = theDemo
self.tree.Expand(root)
EVT_TREE_ITEM_EXPANDED (self.tree, tID, self.OnItemExpanded)
EVT_TREE_ITEM_COLLAPSED (self.tree, tID, self.OnItemCollapsed)
EVT_TREE_SEL_CHANGED (self.tree, tID, self.OnSelChanged)
# Create a Notebook
self.nb = wxNotebook(splitter2, -1)
@ -109,13 +117,10 @@ class wxPythonDemo(wxFrame):
# Set up a TextCtrl on the Demo Code Notebook page
self.txt = wxTextCtrl(self.nb, -1, '', wxDefaultPosition, wxDefaultSize,
wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
self.txt.SetFont(wxFont(9, wxMODERN, wxNORMAL, wxNORMAL, false))
self.nb.AddPage(self.txt, "Demo Code")
# select initial items
self.nb.SetSelection(0)
self.tree.SelectItem(root)
# Set up a log on the View Log Notebook page
self.log = wxTextCtrl(splitter2, -1, '', wxDefaultPosition, wxDefaultSize,
wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
@ -135,6 +140,13 @@ class wxPythonDemo(wxFrame):
# make our log window be stdout
#sys.stdout = self
# select initial items
self.nb.SetSelection(0)
self.tree.SelectItem(root)
if selectedDemo:
self.tree.SelectItem(selectedDemo)
self.tree.EnsureVisible(selectedDemo)
#---------------------------------------------
def WriteText(self, text):
self.log.WriteText(text)
@ -201,9 +213,14 @@ class wxPythonDemo(wxFrame):
# Get the Demo files
def GetDemoFile(self, filename):
self.txt.Clear()
if not self.txt.LoadFile(filename):
#if not self.txt.LoadFile(filename):
# self.txt.WriteText("Cannot open %s file." % filename)
try:
self.txt.SetValue(open(filename).read())
except IOException:
self.txt.WriteText("Cannot open %s file." % filename)
self.txt.SetInsertionPoint(0)
self.txt.ShowPosition(0)

175
utils/wxPython/demo/PrintFramework.py Normal file
View File

@ -0,0 +1,175 @@
from wxPython.wx import *
from wxPython.lib.sizers import *
from wxScrolledWindow import MyCanvas
#----------------------------------------------------------------------
class MyPrintout(wxPrintout):
def __init__(self, canvas, log):
wxPrintout.__init__(self)
self.canvas = canvas
self.log = log
def OnBeginDocument(self, start, end):
self.log.WriteText("wxPrintout.OnBeginDocument\n")
return self.base_OnBeginDocument(start, end)
def OnEndDocument(self):
self.log.WriteText("wxPrintout.OnEndDocument\n")
def OnBeginPrinting(self):
self.log.WriteText("wxPrintout.OnBeginPrinting\n")
def OnEndPrinting(self):
self.log.WriteText("wxPrintout.OnEndPrinting\n")
def OnPreparePrinting(self):
self.log.WriteText("wxPrintout.OnPreparePrinting\n")
def HasPage(self, page):
self.log.WriteText("wxPrintout.HasPage\n")
if page == 1:
return true
else:
return false
def GetPageInfo(self):
self.log.WriteText("wxPrintout.GetPageInfo\n")
return (1, 1, 1, 1)
def OnPrintPage(self, page):
self.log.WriteText("wxPrintout.OnPrintPage\n")
dc = self.GetDC()
#-------------------------------------------
# One possible method of setting scaling factors...
maxX = self.canvas.getWidth()
maxY = self.canvas.getHeight()
# Let's have at least 50 device units margin
marginX = 50
marginY = 50
# Add the margin to the graphic size
maxX = maxX + (2 * marginX)
maxY = maxY + (2 * marginY)
# Get the size of the DC in pixels
(w, h) = dc.GetSizeTuple()
# Calculate a suitable scaling factor
scaleX = float(w) / maxX
scaleY = float(h) / maxY
# Use x or y scaling factor, whichever fits on the DC
actualScale = min(scaleX, scaleY)
# Calculate the position on the DC for centring the graphic
posX = (w - (self.canvas.getWidth() * actualScale)) / 2.0
posY = (h - (self.canvas.getHeight() * actualScale)) / 2.0
# Set the scale and origin
dc.SetUserScale(actualScale, actualScale)
dc.SetDeviceOrigin(int(posX), int(posY))
#-------------------------------------------
self.canvas.DoDrawing(dc)
return true
#----------------------------------------------------------------------
class TestPrintPanel(wxPanel):
def __init__(self, parent, frame, log):
wxPanel.__init__(self, parent, -1)
self.log = log
self.frame = frame
self.printData = wxPrintData()
self.printData.SetPaperId(wxPAPER_LETTER)
self.box = box.wxBoxSizer(wxVERTICAL)
self.canvas = MyCanvas(self)
self.box.Add(self.canvas, 1)
subbox = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(self, 1201, "Print Setup")
EVT_BUTTON(self, 1201, self.OnPrintSetup)
subbox.Add(btn, 1)
btn = wxButton(self, 1202, "Print Preview")
EVT_BUTTON(self, 1202, self.OnPrintPreview)
subbox.Add(btn, 1)
btn = wxButton(self, 1203, "Print")
EVT_BUTTON(self, 1203, self.OnDoPrint)
subbox.Add(btn, 1)
self.box.Add(subbox)
def OnSize(self, event):
size = self.GetClientSize()
self.box.Layout(size)
def OnPrintSetup(self, event):
printerDialog = wxPrintDialog(self)
printerDialog.GetPrintDialogData().SetPrintData(self.printData)
printerDialog.GetPrintDialogData().SetSetupDialog(true)
printerDialog.ShowModal();
self.printData = printerDialog.GetPrintDialogData().GetPrintData()
printerDialog.Destroy()
def OnPrintPreview(self, event):
self.log.WriteText("OnPrintPreview\n")
printout = MyPrintout(self.canvas, self.log)
printout2 = MyPrintout(self.canvas, self.log)
self.preview = wxPrintPreview(printout, printout2, self.printData)
if not self.preview.Ok():
self.log.WriteText("Houston, we have a problem...\n")
return
frame = wxPreviewFrame(self.preview, self.frame, "This is a print preview")
frame.Initialize()
frame.SetPosition(self.frame.GetPosition())
frame.SetSize(self.frame.GetSize())
frame.Show(true)
def OnDoPrint(self, event):
pdd = wxPrintDialogData()
pdd.SetPrintData(self.printData)
printer = wxPrinter(pdd)
printout = MyPrintout(self.canvas, self.log)
if not printer.Print(self.frame, printout):
wxMessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wxOK)
else:
self.printData = printer.GetPrintDialogData().GetPrintData()
printout.Destroy()
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPrintPanel(nb, frame, log)
return win
#----------------------------------------------------------------------
overview = """\
"""

362
utils/wxPython/demo/Sizers.py Normal file
View File

@ -0,0 +1,362 @@
#----------------------------------------------------------------------
# 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)
btn = wxButton(win, 1010, "one")
box.Add(btn)
box2 = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(win, 1010, "two")
box2.Add(btn)
btn = wxButton(win, 1010, "three")
box2.Add(btn)
btn = wxButton(win, 1010, "four")
box2.Add(btn)
btn = wxButton(win, 1010, "five")
box2.Add(btn)
box3 = wxBoxSizer(wxVERTICAL)
box3.AddMany([ (wxButton(win, 1010, "six"), 1),
(wxButton(win, 1010, "seven"), 2),
(wxButton(win, 1010, "eight"), 1),
(wxButton(win, 1010, "nine"), 1),
])
box2.Add(box3, 1)
box.Add(box2, 1)
btn = wxButton(win, 1010, "ten")
box.Add(btn)
return box
#----------------------------------------------------------------------
def makeBoxInBorder(win):
bdr = wxBorderSizer(wxALL)
box = makeSimpleBox3(win)
bdr.Add(box, 15)
return bdr
#----------------------------------------------------------------------
def makeBorderInBox(win):
insideBox = wxBoxSizer(wxHORIZONTAL)
insideBox.Add(makeSimpleBox3(win), 1)
bdr = wxBorderSizer(wxALL)
bdr.Add(wxButton(win, 1010, "border"), 20)
insideBox.Add(bdr, 1)
box3 = wxBoxSizer(wxVERTICAL)
box3.AddMany([ (wxButton(win, 1010, "six"), 1),
(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,
""
),
]
#----------------------------------------------------------------------
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.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.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()
#----------------------------------------------------------------------

2
utils/wxPython/demo/demo.py
View File

@ -1,5 +1,7 @@
#!/bin/env python
import sys
sys.path.insert(0, 'e:/projects/wx/utils')
import Main
Main.main()

2
utils/wxPython/demo/hangman.py
View File

@ -386,9 +386,11 @@ class MyFrame(wxFrame):
def OnChar(self, event):
if not self.in_progress:
#print "new"
self.OnGameNew(None)
return
key = event.KeyCode();
#print key
if key >= ord('A') and key <= ord('Z'):
key = key + ord('a') - ord('A')
key = chr(key)

15
utils/wxPython/demo/wxListBox.py
View File

@ -16,30 +16,33 @@ class TestListBox(wxPanel):
wxPoint(45, 10))
wxStaticText(self, -1, "Select one:", wxPoint(15, 50), wxSize(65, 18))
lb = wxListBox(self, 60, wxPoint(80, 50), wxSize(80, 120),
self.lb1 = wxListBox(self, 60, wxPoint(80, 50), wxSize(80, 120),
sampleList, wxLB_SINGLE)
EVT_LISTBOX(self, 60, self.EvtListBox)
EVT_LISTBOX_DCLICK(self, 60, self.EvtListBoxDClick)
lb.SetSelection(0)
EVT_RIGHT_UP(self.lb1, self.EvtRightButton)
self.lb1.SetSelection(0)
wxStaticText(self, -1, "Select many:", wxPoint(200, 50), wxSize(65, 18))
self.lb = wxListBox(self, 70, wxPoint(280, 50), wxSize(80, 120),
self.lb2 = wxListBox(self, 70, wxPoint(280, 50), wxSize(80, 120),
sampleList, wxLB_EXTENDED)
EVT_LISTBOX(self, 70, self.EvtMultiListBox)
EVT_LISTBOX_DCLICK(self, 70, self.EvtListBoxDClick)
self.lb.SetSelection(0)
self.lb2.SetSelection(0)
def EvtListBox(self, event):
self.log.WriteText('EvtListBox: %s\n' % event.GetString())
def EvtListBoxDClick(self, event):
self.log.WriteText('EvtListBoxDClick:\n')
self.log.WriteText('EvtListBoxDClick: %s\n' % self.lb1.GetSelection())
def EvtMultiListBox(self, event):
self.log.WriteText('EvtMultiListBox: %s\n' % str(self.lb.GetSelections()))
self.log.WriteText('EvtMultiListBox: %s\n' % str(self.lb2.GetSelections()))
def EvtRightButton(self, event):
self.log.WriteText('EvtRightButton: %s\n' % event.GetPosition())
#---------------------------------------------------------------------------

17
utils/wxPython/demo/wxListCtrl.py
View File

@ -44,6 +44,23 @@ class TestListCtrlPanel(wxPanel):
self.list.SetColumnWidth(1, wxLIST_AUTOSIZE)
self.list.SetColumnWidth(2, wxLIST_AUTOSIZE)
self.list.SetItemState(5, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED)
self.currentItem = 0
EVT_LIST_ITEM_SELECTED(self, tID, self.OnItemSelected)
EVT_LEFT_DCLICK(self.list, self.OnDoubleClick)
EVT_COMMAND_RIGHT_CLICK(self.list, tID, self.OnRightClick)
def OnItemSelected(self, event):
self.currentItem = event.m_itemIndex
self.log.WriteText("OnItemSelected: %s\n" % self.list.GetItemText(self.currentItem))
def OnDoubleClick(self, event):
self.log.WriteText("OnDoubleClick item %s\n" % self.list.GetItemText(self.currentItem))
def OnRightClick(self, event):
self.log.WriteText("OnRightClick %s\n" % self.list.GetItemText(self.currentItem))
def OnSize(self, event):
w,h = self.GetClientSizeTuple()

38
utils/wxPython/demo/wxProgressDialog.py Normal file
View File

@ -0,0 +1,38 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
max = 20
dlg = wxProgressDialog("Progress dialog example",
"An informative message",
max,
frame,
wxPD_CAN_ABORT | wxPD_APP_MODAL)
keepGoing = true
count = 0
while keepGoing and count <= max:
count = count + 1
wxSleep(1)
if count == max / 2:
keepGoing = dlg.Update(count, "Half-time!")
else:
keepGoing = dlg.Update(count)
dlg.Destroy()
#---------------------------------------------------------------------------
overview = """\
"""

21
utils/wxPython/demo/wxScrolledWindow.py
View File

@ -8,6 +8,8 @@ class MyCanvas(wxScrolledWindow):
wxScrolledWindow.__init__(self, parent, -1, wxPoint(0, 0), wxPyDefaultSize, wxSUNKEN_BORDER)
self.lines = []
self.maxWidth = 1000
self.maxHeight = 1000
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.Connect(-1, -1, wxEVT_LEFT_DOWN, self.OnLeftButtonEvent)
@ -15,10 +17,16 @@ class MyCanvas(wxScrolledWindow):
self.Connect(-1, -1, wxEVT_MOTION, self.OnLeftButtonEvent)
self.SetCursor(wxStockCursor(wxCURSOR_PENCIL))
#bmp = wxBitmap('bitmaps/image.bmp', wxBITMAP_TYPE_BMP)
#self.bmp = bmp
bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP)
self.bmp = bmp
self.SetScrollbars(20, 20, 50, 50)
self.SetScrollbars(20, 20, self.maxWidth/20, self.maxHeight/20)
def getWidth(self):
return self.maxWidth
def getHeight(self):
return self.maxHeight
def OnPaint(self, event):
@ -29,7 +37,6 @@ class MyCanvas(wxScrolledWindow):
def DoDrawing(self, dc):
dc.BeginDrawing()
#dc.Clear()
pen1 = wxPen(wxNamedColour('RED'))
dc.SetPen(pen1)
dc.DrawRectangle(5, 5, 50, 50)
@ -54,9 +61,9 @@ class MyCanvas(wxScrolledWindow):
dc.SetPen(wxGREEN_PEN)
dc.DrawSpline(lst+[(100,100)])
#dc.DrawBitmap(self.bmp, 200, 20)
#dc.SetTextForeground(wxColour(0, 0xFF, 0x80))
#dc.DrawText("a bitmap", 200, 80)
dc.DrawBitmap(self.bmp, 200, 20)
dc.SetTextForeground(wxColour(0, 0xFF, 0x80))
dc.DrawText("a bitmap", 200, 85)
self.DrawSavedLines(dc)
dc.EndDrawing()

20
utils/wxPython/demo/wxTreeCtrl.py
View File

@ -24,6 +24,26 @@ class TestTreeCtrlPanel(wxPanel):
EVT_TREE_ITEM_COLLAPSED (self, tID, self.OnItemCollapsed)
EVT_TREE_SEL_CHANGED (self, tID, self.OnSelChanged)
EVT_LEFT_DCLICK(self.tree, self.OnLeftDClick)
EVT_RIGHT_DOWN(self.tree, self.OnRightClick)
EVT_RIGHT_UP(self.tree, self.OnRightUp)
def OnRightClick(self, event):
(x,y) = event.Position();
item = self.tree.HitTest(wxPoint(x,y))
self.log.WriteText("OnRightClick: %s\n" % self.tree.GetItemText(item))
self.tree.SelectItem(item)
def OnRightUp(self, event):
(x,y) = event.Position();
item = self.tree.HitTest(wxPoint(x,y))
self.log.WriteText("OnRightUp: %s\n" % self.tree.GetItemText(item))
def OnLeftDClick(self, event):
(x,y) = event.Position();
item = self.tree.HitTest(wxPoint(x,y))
self.log.WriteText("OnLeftDClick: %s\n" % self.tree.GetItemText(item))
def OnSize(self, event):
w,h = self.GetClientSizeTuple()

240
utils/wxPython/distrib/wxPython.wse
View File

@ -1,7 +1,7 @@
Document Type: WSE
item: Global
Version=6.01
Title=wxPython 2.0 Installation
Title=wxPython 2.1 Installation
Flags=10010111
Languages=65 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Japanese Font Name=MS Gothic
@ -17,7 +17,7 @@ item: Global
Patch Flags=0000000000001001
Patch Threshold=85
Patch Memory=4000
EXE Filename=wxPython-2.0b9.exe
EXE Filename=wxPython-2.1b1.exe
FTP Cluster Size=20
Per-User Version ID=1
Dialogs Version=6
@ -55,11 +55,12 @@ item: End Block
end
item: Set Variable
Variable=APPTITLE
Value=wxPython 2.0
Value=wxPython 2.1
Flags=10000000
end
item: Set Variable
Variable=GROUP
Value=wxPython 2.1
Flags=10000000
end
item: Set Variable
@ -156,7 +157,6 @@ item: Set Variable
end
item: Set Variable
Variable=COMPONENTS
Value=A
Flags=10000000
end
item: Set Variable
@ -642,168 +642,6 @@ item: Custom Dialog Set
end
end
end
item: Custom Dialog Set
Name=Select Components
Display Variable=DISPLAY
Flags=00000001
item: Dialog
Title=Select Components
Title French=Sélectionner les éléments
Title German=Komponenten auswählen
Title Portuguese=Seleccionar Componentes
Title Spanish=Seleccione los Componentes
Title Italian=Seleziona Componenti
Title Danish=Vælg komponenter
Title Dutch=Selecteer onderdelen
Title Norwegian=Velg komponenter
Title Swedish=Välj komponenter
Width=280
Height=224
Font Name=Helv
Font Size=8
item: Push Button
Rectangle=172 185 214 199
Variable=DIRECTION
Value=N
Create Flags=01010000000000010000000000000001
Text=&Next >
Text French=&Suivant>
Text German=&Weiter>
Text Portuguese=&Próximo>
Text Spanish=&Siguiente >
Text Italian=&Avanti >
Text Danish=&Næste>
Text Dutch=&Volgende>
Text Norwegian=&Neste>
Text Swedish=&Nästa >
end
item: Push Button
Rectangle=130 185 172 199
Variable=DIRECTION
Value=B
Create Flags=01010000000000010000000000000000
Text=< &Back
Text French=<&Retour
Text German=<&Zurück
Text Portuguese=<&Retornar
Text Spanish=<&Retroceder
Text Italian=< &Indietro
Text Danish=<&Tilbage
Text Dutch=<&Terug
Text Norwegian=<&Tilbake
Text Swedish=< &Tillbaka
end
item: Push Button
Rectangle=222 185 264 199
Action=3
Create Flags=01010000000000010000000000000000
Text=Cancel
Text French=Annuler
Text German=Abbrechen
Text Portuguese=Cancelar
Text Spanish=Cancelar
Text Italian=Annulla
Text Danish=Annuller
Text Dutch=Annuleren
Text Norwegian=Avbryt
Text Swedish=Avbryt
end
item: Static
Rectangle=9 177 263 178
Action=3
Create Flags=01010000000000000000000000000111
end
item: Static
Rectangle=205 156 253 166
Variable=COMPONENTS
Value=MAINDIR
Create Flags=01010000000000000000000000000010
end
item: Static
Rectangle=205 148 253 157
Variable=COMPONENTS
Create Flags=01010000000000000000000000000010
end
item: Static
Rectangle=95 147 184 158
Create Flags=01010000000000000000000000000000
Text=Disk Space Required:
Text French=Espace disque requis
Text German=Benötigter Festplattenspeicher:
Text Portuguese=Espaço de disco necessário:
Text Spanish=Espacio de Disco Requerido:
Text Italian=Spazio su disco richiesto:
Text Danish=Nødvendig diskplads:
Text Dutch=Vereiste hoeveelheid schijfruimte
Text Norwegian=Diskplass nødvendig:
Text Swedish=Erforderligt diskutrymme
end
item: Static
Rectangle=95 157 190 167
Create Flags=01010000000000000000000000000000
Text=Disk Space Remaining:
Text French=Espace disque disponible
Text German=Verbleibender Festplattenspeicher:
Text Portuguese=Espaço de disco restante:
Text Spanish=Espacio de Disco Remanente:
Text Italian=Spazio su disco rimanente:
Text Danish=Ledig diskplads:
Text Dutch=Resterende schijfruimte
Text Norwegian=Ledig diskplass:
Text Swedish=Återstående diskutrymme
end
item: Static
Rectangle=90 138 264 168
Action=1
Create Flags=01010000000000000000000000000111
end
item: Static
Rectangle=90 8 260 41
Create Flags=01010000000000000000000000000000
Text=In the options list below, select the checkboxes for the options that you would like to have installed. The disk space fields reflect the requirements of the options you have selected.
Text French=Dans la liste d'options suivante, veuillez sélectionner les cases des options que vous désirez installer. Le champ d'espace disque indique les conditions requises pour les options choisies
Text German=Wählen Sie in der Optionenliste unten die Kontrollkästchen für diejenigen Optionen, die Sie installieren möchten. Die Speicherfelder zeigen die benötigte Speicherkapazität für die gewählten Optionen an.
Text Portuguese=Na lista de opções abaixo, seleccione as caixas de verificação para as opções que gostaria de ter instalado. Os campos de espaço de disco reflectem os requerimentos das opções que seleccionou.
Text Spanish=En la lista de opciones que se ofrece a continuación, seleccione las casillas de comprobación para las opciones que desea instalar. Los campos del espacio en el disco reflejan los requerimientos de las opciones que ha seleccionado.
Text Italian=Nell’elenco delle opzioni sotto, marca le caselle di controllo delle opzioni che vuoi installare. I campi dello spazio sul disco riflettono i requisiti delle opzioni selezionate.
Text Danish=Marker afkrydsningsfelterne for de komponenter, der skal installeres, på listen herunder. Diskpladsfelterne angiver pladskravene for de valgte komponenter.
Text Dutch=Kruis in de onderstaande lijst het vakje aan naast de opties die u wilt installeren. Achter elke optie staat de benodigde schijfruimte vermeld.
Text Norwegian=I listen over alternativer nedenfor, klikk i kontrollrutene for de alternativene du ønsker å installere. Diskplassfeltene gjenspeiler kravene for de alternativene du har valgt.
Text Swedish=Kryssa för i rutorna nedan vilka alternativ du vill få installerade. I diskutrymmesfälten anges utrymmesbehoven för de alternativ du väljer.
end
item: Listbox
Rectangle=90 42 263 133
Variable=COMPONENTS
Create Flags=01010000101000010000000101010001
Flags=0000010001000111
Text=wxPython package (you need this one!)
Text=wxPython documentation
Text=
Text French=wxPython package (you need this one!)
Text French=wxPython documentation
Text French=
Text German=wxPython package (you need this one!)
Text German=wxPython documentation
Text German=
Text Portuguese=%1%
Text Portuguese=
Text Spanish=wxPython package (you need this one!)
Text Spanish=wxPython documentation
Text Spanish=
Text Italian=wxPython package (you need this one!)
Text Italian=wxPython documentation
Text Italian=
Text Danish=%1%
Text Danish=
Text Dutch=%1%
Text Dutch=
Text Norwegian=%1%
Text Norwegian=
Text Swedish=%1%
Text Swedish=
end
end
end
item: Custom Dialog Set
Name=Start Installation
Display Variable=DISPLAY
@ -966,11 +804,13 @@ item: Check Disk Space
end
item: Remark
end
item: If/While Statement
remarked item: If/While Statement
Variable=COMPONENTS
Value=A
Flags=00001010
end
remarked item: End Block
end
item: Install File
Source=c:\WINNT\System32\Msvcirt.dll
Destination=%SYS%\Msvcirt.dll
@ -981,6 +821,11 @@ item: Install File
Destination=%SYS%\Msvcrt.dll
Flags=0000001010000011
end
item: Install File
Source=e:\projects\wx\lib\wx200.dll
Destination=%SYS%\wx200.dll
Flags=0000001010010010
end
item: Install File
Source=e:\Projects\wx\utils\wxPython\*.py
Destination=%MAINDIR%\wxPython
@ -1005,6 +850,12 @@ item: Install File
Description=wxPython Standard Library
Flags=0000000010000010
end
item: Install File
Source=e:\Projects\wx\utils\wxPython\lib\sizers\*.py
Destination=%MAINDIR%\wxPython\lib\sizers
Description=wxPython Standard Library
Flags=0000000010000010
end
item: Install File
Source=e:\Projects\wx\utils\wxPython\demo\*.py
Destination=%MAINDIR%\wxPython\demo
@ -1041,28 +892,34 @@ item: Install File
Description=Demos
Flags=0000000010000010
end
item: End Block
item: Remark
end
item: Install File
Source=E:\PROJECTS\wx\docs\html\wx\wx.chm
Destination=%MAINDIR%\wxPython\docs\wx.chm
Description=wxPython documentation
Flags=0000000010000010
end
item: Remark
end
item: If/While Statement
remarked item: If/While Statement
Variable=COMPONENTS
Value=B
Flags=00001010
end
item: Install File
remarked item: Install File
Source=e:\projects\wx\docs\html\wx\*.*
Destination=%MAINDIR%\wxPython\docs
Description=wxPython documentation
Flags=0000000010000010
end
item: Install File
remarked item: Install File
Source=e:\projects\wx\docs\html\wx\wx.htm
Destination=%MAINDIR%\wxPython\docs\index.htm
Description=wxPython documentation
Flags=0000000010000010
end
item: End Block
remarked item: End Block
end
item: Remark
end
@ -1126,11 +983,6 @@ item: Edit Registry
end
item: Else Statement
end
item: Add ProgMan Icon
Group=%GROUP%
Icon Name=Uninstall %APPTITLE%
Command Line=%UNINSTALL_PATH% %INST_LOG_PATH%
end
item: End Block
end
item: Remark
@ -1219,8 +1071,42 @@ item: Set Variable
Variable=GROUP
Value=%GROUPDIR%\%GROUP%
end
item: Create Shortcut
Source=%UNINSTALL_PATH%
Destination=%CGROUPDIR%\%CGROUP_SAVE%\Uninstall %APPTITLE%.lnk
Command Options=%INST_LOG_PATH%
Icon Number=0
end
item: Create Shortcut
Source=pythonw.exe
Destination=%CGROUPDIR%\%CGROUP_SAVE%\Run the DEMO.lnk
Command Options=demo.py
Working Directory=%MAINDIR%\wxPython\demo
Icon Number=0
end
item: Create Shortcut
Source=%MAINDIR%\wxPython\docs\wx.chm
Destination=%CGROUPDIR%\%CGROUP_SAVE%\wxWindows User Guide.lnk
Icon Number=0
end
item: Else Statement
end
item: Add ProgMan Icon
Group=%GROUP%
Icon Name=Uninstall %APPTITLE%
Command Line=%UNINSTALL_PATH% %INST_LOG_PATH%
end
item: Add ProgMan Icon
Group=%GROUP%
Icon Name=Run the DEMO
Command Line=pythonw.exe demo.py
Default Directory=%MAINDIR%\wxPython\demo
end
item: Add ProgMan Icon
Group=%GROUP%
Icon Name=wxWindows User Guide
Command Line=%MAINDIR%\wxPython\docs\wx.chm
end
item: End Block
end
item: Self-Register OCXs/DLLs

BIN
utils/wxPython/distrib/wxPython.wsm
View File

Binary file not shown.

2
utils/wxPython/lib/sizers/.cvsignore Normal file
View File

@ -0,0 +1,2 @@
*.pyc

18
utils/wxPython/lib/sizers/__init__.py Normal file
View File

@ -0,0 +1,18 @@
#----------------------------------------------------------------------------
# Name: __init__.py
# Purpose: The presence of this file turns this directory into a
# Python package.
#
# Author: Robin Dunn
#
# Created: 18-May-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
from sizer import *
from box import *
from border import *
#----------------------------------------------------------------------------

109
utils/wxPython/lib/sizers/border.py Normal file
View File

@ -0,0 +1,109 @@
#----------------------------------------------------------------------
# Name: wxPython.lib.sizers.border
# Purpose: A Sizer that wraps an empty border around its contents
#
# Author: Robin Dunn
#
# Created: 9-June-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------
from sizer import wxSizer
wxNORTH = 1
wxSOUTH = 2
wxEAST = 4
wxWEST = 8
wxALL = wxNORTH | wxSOUTH | wxEAST | wxWEST
#----------------------------------------------------------------------
class wxBorderSizer(wxSizer):
"""
wxBorderSizer
This sizer provides an empty buffer on one or more sides of it's
contents. It can only hold a single widget, but that can be a
sizer containing other items if you wish.
The sizer is constructed with a parameter specifying which sides
should have the border. You can use a logical OR of the following
values to specify the sides:
wxNORTH -- the top side
wxSOUTH -- the bottom side
wxEAST -- the right side
wxWEST -- the left side
wxALL -- all sides
The width in pixels of the border is specified when the child
widget is Added to the sizer.
"""
def __init__(self, sides = wxALL):
wxSizer.__init__(self)
self.sides = sides
def Add(self, widget, borderSize):
if self.children:
raise ValueError("wxBorderSizer can only contain one child.")
wxSizer.Add(self, widget, borderSize)
def CalcMin(self):
isSizer, widget, width, height, borderSize = self.children[0]
if isSizer:
width, height = widget.CalcMin()
if self.sides & wxEAST:
width = width + borderSize
if self.sides & wxWEST:
width = width + borderSize
if self.sides & wxNORTH:
height = height + borderSize
if self.sides & wxSOUTH:
height = height + borderSize
return width, height
def RecalcSizes(self):
isSizer, widget, width, height, borderSize = self.children[0]
width = self.size.width
height = self.size.height
px = self.origin.x
py = self.origin.y
if self.sides & wxWEST:
width = width - borderSize
px = px + borderSize
if self.sides & wxEAST:
width = width - borderSize
if self.sides & wxNORTH:
height = height - borderSize
py = py + borderSize
if self.sides & wxSOUTH:
height = height - borderSize
widget.SetDimensions(px, py, width, height)
#----------------------------------------------------------------------
#
# TODO... Make an abstract class wxBorder whose decendants can be added to
# a wxBorderSizer to provide drawing for the buffer area. Ideas are
# to provide a color border, beveled borders, rounded borders, etc.

137
utils/wxPython/lib/sizers/box.py Normal file
View File

@ -0,0 +1,137 @@
#----------------------------------------------------------------------
# Name: wxPython.lib.sizers.box
# Purpose: A sizer/layout managers for wxPython that places items in
# a stretchable box
#
# Author: Robin Dunn and Dirk Holtwick
#
# Created: 17-May-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------
from sizer import wxSizer
from wxPython.wx import wxVERTICAL, wxHORIZONTAL
#----------------------------------------------------------------------
class wxBoxSizer(wxSizer):
"""
wxBoxSizer
A Sizer that lays components out in a box, in the order they are
added to the layout manager, with a given orientation. The
orientation is specified in the constructor with either wxVERTICAL
or wxHORIZONTAL.
The optional parameter to the Add method (for this sizer it's
called the stretch flag) can be used to flag one or more components
as stretchable, meaning that they will expand to fill available
space in the given orientation. The default is zero, or not
stretchable.
If the stretch flag is non-zero then the widget will stretch. If
the sizer holds more than one item that is stretchable then they
share the available space.
If the strech flag is greater than 1 then it serves as a weighting
factor. Widgets with a flag of 2 will get twice as much space as
widgets with 1, etc.
"""
def __init__(self, orientation, size = None):
wxSizer.__init__(self, size)
self.orientation = orientation
def CalcMin(self):
self.stretchable = 0 # number of stretchable items
self.minWidth = 0 # minimal size
self.minHeight = 0
self.fixedWidth = 0 # size without stretched widgets
self.fixedHeight = 0
# iterate through children
for (isSizer, widget, width, height, stretch) in self.children:
weight = 1
if stretch:
weight = stretch
if isSizer:
# let sub-sizers recalc their required space
width, height = widget.CalcMin()
# minimal size
if self.orientation == wxVERTICAL:
self.minHeight = self.minHeight + (height * weight)
self.minWidth = max(self.minWidth, width)
else:
self.minWidth = self.minWidth + (width * weight)
self.minHeight = max(self.minHeight, height)
# stretchable items
if stretch:
self.stretchable = self.stretchable + weight
else:
if self.orientation == wxVERTICAL:
self.fixedHeight = self.fixedHeight + height
self.fixedWidth = max(self.fixedWidth, width)
else:
self.fixedWidth = self.fixedWidth + width
self.fixedHeight = max(self.fixedHeight, height)
return self.minWidth, self.minHeight
def RecalcSizes(self):
# get current dimensions, for performance
myWidth = self.size.width
myHeight = self.size.height
# relative recent positions & sizes
px = self.origin.x
py = self.origin.y
newWidth = 0
newHeight = 0
# calculate space for one stretched item
if self.stretchable:
if self.orientation == wxHORIZONTAL:
delta = (myWidth - self.fixedWidth) / self.stretchable
extra = (myWidth - self.fixedWidth) % self.stretchable
else:
delta = (myHeight - self.fixedHeight) / self.stretchable
extra = (myHeight - self.fixedHeight) % self.stretchable
# iterate children ...
for (isSizer, widget, width, height, stretch) in self.children:
weight = 1
if stretch:
weight = stretch
if isSizer:
width, height = widget.CalcMin()
# ... vertical
if self.orientation == wxVERTICAL:
newHeight = height
if stretch:
newHeight = (delta * weight) + extra # first stretchable gets extra pixels
extra = 0
widget.SetDimensions(px, py, myWidth, newHeight)
# ... horizontal
elif self.orientation == wxHORIZONTAL:
newWidth = width
if stretch:
newWidth = (delta * weight) + extra # first stretchable gets extra pixels
extra = 0
widget.SetDimensions(px, py, newWidth, myHeight)
px = px + newWidth
py = py + newHeight
#----------------------------------------------------------------------

110
utils/wxPython/lib/sizers/sizer.py Normal file
View File

@ -0,0 +1,110 @@
#----------------------------------------------------------------------
# Name: wxPython.lib.sizers.sizer
# Purpose: General purpose sizer/layout managers for wxPython
#
# Author: Robin Dunn and Dirk Holtwick
#
# Created: 17-May-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------
from wxPython.wx import wxPoint, wxSize
#----------------------------------------------------------------------
class wxSizer:
"""
wxSizer
An abstract base sizer class. A sizer is able to manage the size and
layout of windows and/or child sizers.
Derived classes should implement CalcMin, and RecalcSizes.
A window or sizer is added to this sizer with the Add method:
def Add(self, widget, opt=0)
The meaning of the opt parameter is different for each type of
sizer. It may be a single value or a collection of values.
"""
def __init__(self, size = None):
self.children = []
self.origin = wxPoint(0, 0)
if not size:
size = wxSize(0,0)
self.size = size
def Add(self, widget, opt=0):
"""
Add a window or a sizer to this sizer. The meaning of the opt
parameter is different for each type of sizer. It may be a single
value or a collection of values.
"""
size = widget.GetSize()
isSizer = isinstance(widget, wxSizer)
self.children.append( (isSizer, widget, size.width, size.height, opt) )
def AddMany(self, widgets):
"""
Add a sequence (list, tuple, etc.) of widgets to this sizer. The
items in the sequence should be tuples containing valid args for
the Add method.
"""
for childinfo in widgets:
apply(self.Add, childinfo)
def SetDimensions(self, x, y, width, height):
self.origin = wxPoint(x, y)
self.size = wxSize(width, height)
self.RecalcSizes()
def GetSize(self):
return self.size
def GetPosition(self):
return self.origin
def CalcMin(self):
raise NotImplementedError("Derived class should implement CalcMin")
def RecalcSizes(self):
raise NotImplementedError("Derived class should implement RecalcSizes")
def __getMinWindowSize(self, win):
"""
Calculate the best size window to hold this sizer, taking into
account the difference between client size and window size.
"""
min = self.GetMinSize()
a1,a2 = win.GetSizeTuple()
b1,b2 = win.GetClientSizeTuple()
w = min.width + (a1 - b1)
h = min.height + (a2 - b2)
return (w, h)
def GetMinSize(self):
minWidth, minHeight = self.CalcMin()
return wxSize(minWidth, minHeight)
def SetWindowSizeHints(self, win):
w, h = self.__getMinWindowSize(win)
win.SetSizeHints(w,h)
def FitWindow(self, win):
w, h = self.__getMinWindowSize(win)
win.SetSize(wxSize(w,h))
def Layout(self, size):
self.CalcMin()
self.SetDimensions(self.origin.x, self.origin.y,
size.width, size.height)
#----------------------------------------------------------------------

22
utils/wxPython/src/Makefile.pre.in
View File

@ -324,20 +324,21 @@ distclean: clobber
# Custom rules and dependencies added for wxPython
#
WXP_VERSION=2.0b9
WXP_VERSION=2.1b1
SWIGFLAGS=-c++ -shadow -python -dnone -D__WXGTK__ $(SEPARATE)
PYMODULES = $(GENCODEDIR)/wx.py $(GENCODEDIR)/events.py \
$(GENCODEDIR)/windows.py $(GENCODEDIR)/misc.py \
$(GENCODEDIR)/gdi.py $(GENCODEDIR)/mdi.py \
$(GENCODEDIR)/controls.py $(GENCODEDIR)/controls2.py \
$(GENCODEDIR)/windows2.py $(GENCODEDIR)/cmndlgs.py \
$(GENCODEDIR)/frames.py $(GENCODEDIR)/stattool.py \
$(GENCODEDIR)/utils.py $(GENCODEDIR)/windows3.py \
$(GENCODEDIR)/image.py $(GENCODEDIR)/glcanvas.py \
__init__.py
PYMODULES = $(TARGETDIR)\wx.py $(TARGETDIR)\events.py \
$(TARGETDIR)\windows.py $(TARGETDIR)\misc.py \
$(TARGETDIR)\gdi.py $(TARGETDIR)\mdi.py \
$(TARGETDIR)\controls.py $(TARGETDIR)\controls2.py \
$(TARGETDIR)\windows2.py $(TARGETDIR)\cmndlgs.py \
$(TARGETDIR)\stattool.py $(TARGETDIR)\frames.py \
$(TARGETDIR)\windows3.py $(TARGETDIR)\__init__.py \
$(TARGETDIR)\utils.py $(TARGETDIR)\image.py \
$(TARGETDIR)\printfw.py $(TARGETDIR)\misc2.py \
$(TARGETDIR)\glcanvas.py
# Implicit rules to run SWIG
@ -359,6 +360,7 @@ $(GENCODEDIR)/windows2.cpp $(GENCODEDIR)/windows2.py : windows2.i my_typemap
$(GENCODEDIR)/windows3.cpp $(GENCODEDIR)/windows3.py : windows3.i my_typemaps.i _defs.i
$(GENCODEDIR)/events.cpp $(GENCODEDIR)/events.py : events.i my_typemaps.i _defs.i
$(GENCODEDIR)/misc.cpp $(GENCODEDIR)/misc.py : misc.i my_typemaps.i _defs.i
$(GENCODEDIR)/misc2.cpp $(GENCODEDIR)/misc2.py : misc2.i my_typemaps.i _defs.i
$(GENCODEDIR)/gdi.cpp $(GENCODEDIR)/gdi.py : gdi.i my_typemaps.i _defs.i
$(GENCODEDIR)/mdi.cpp $(GENCODEDIR)/mdi.py : mdi.i my_typemaps.i _defs.i
$(GENCODEDIR)/controls.cpp $(GENCODEDIR)/controls.py : controls.i my_typemaps.i _defs.i

2
utils/wxPython/src/Setup.in
View File

@ -33,7 +33,7 @@ MY_LINKCC=$(CCC)
TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
wxc wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
wxc wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp misc2.cpp gdi.cpp \
mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
frames.cpp stattool.cpp windows3.cpp image.cpp \
utils.cpp \

32
utils/wxPython/src/__init__.py
View File

@ -11,33 +11,9 @@
# Licence: wxWindows license
#----------------------------------------------------------------------------
# ensure the main extension module is loaded, in case the embedded modules
# (such as utils,) are used standalone. This hack should go away soon.
import wxc
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.3 1998/12/15 20:41:12 RD
# Changed the import semantics from "from wxPython import *" to "from
# wxPython.wx import *" This is for people who are worried about
# namespace pollution, they can use "from wxPython import wx" and then
# prefix all the wxPython identifiers with "wx."
#
# Added wxTaskbarIcon for wxMSW.
#
# Made the events work for wxGrid.
#
# Added wxConfig.
#
# Added wxMiniFrame for wxGTK, (untested.)
#
# Changed many of the args and return values that were pointers to gdi
# objects to references to reflect changes in the wxWindows API.
#
# Other assorted fixes and additions.
#
# Revision 1.2 1998/10/07 07:34:32 RD
# Version 0.4.1 for wxGTK
#
# Revision 1.1 1998/08/09 08:25:49 RD
# Initial version
#
#

140
utils/wxPython/src/_defs.i
View File

@ -152,6 +152,7 @@ typedef int wxWindowID;
typedef unsigned int uint;
typedef signed int EBool;
typedef unsigned int size_t
typedef int wxPrintQuality;
//---------------------------------------------------------------------------
@ -202,6 +203,8 @@ enum {
wxDEFAULT_DIALOG_STYLE,
wxFRAME_TOOL_WINDOW,
wxFRAME_FLOAT_ON_PARENT,
wxCLIP_CHILDREN,
wxRETAINED,
@ -242,6 +245,7 @@ enum {
wxGA_PROGRESSBAR,
wxGA_HORIZONTAL,
wxGA_VERTICAL,
wxGA_SMOOTH,
wxSL_HORIZONTAL,
wxSL_VERTICAL,
wxSL_AUTOTICKS,
@ -321,6 +325,10 @@ enum {
#endif
wxPORTRAIT,
wxLANDSCAPE,
wxPRINT_QUALITY_HIGH,
wxPRINT_QUALITY_MEDIUM,
wxPRINT_QUALITY_LOW,
wxPRINT_QUALITY_DRAFT,
wxID_OPEN,
wxID_CLOSE,
wxID_NEW,
@ -387,6 +395,12 @@ enum {
wxACCEL_ALT,
wxACCEL_CTRL,
wxACCEL_SHIFT,
wxPD_AUTO_HIDE,
wxPD_APP_MODAL,
wxPD_CAN_ABORT,
wxNO_DEFAULT,
};
@ -647,6 +661,12 @@ typedef enum {
} wxPaperSize ;
typedef enum {
wxDUPLEX_SIMPLEX, // Non-duplex
wxDUPLEX_HORIZONTAL,
wxDUPLEX_VERTICAL
} wxDuplexMode;
#define FALSE 0
@ -732,6 +752,17 @@ enum wxEventType {
wxEVT_SCROLL_PAGEDOWN,
wxEVT_SCROLL_THUMBTRACK,
/*
* Scrolled Window
*/
wxEVT_SCROLLWIN_TOP,
wxEVT_SCROLLWIN_BOTTOM,
wxEVT_SCROLLWIN_LINEUP,
wxEVT_SCROLLWIN_LINEDOWN,
wxEVT_SCROLLWIN_PAGEUP,
wxEVT_SCROLLWIN_PAGEDOWN,
wxEVT_SCROLLWIN_THUMBTRACK,
wxEVT_SIZE = wxEVT_FIRST + 200,
wxEVT_MOVE,
wxEVT_CLOSE_WINDOW,
@ -773,6 +804,7 @@ enum wxEventType {
wxEVT_IDLE,
wxEVT_UPDATE_UI,
/* Generic command events */
// Note: a click is a higher-level event
// than button down/up
@ -814,113 +846,23 @@ enum wxEventType {
wxEVT_COMMAND_LIST_KEY_DOWN,
wxEVT_COMMAND_LIST_INSERT_ITEM,
wxEVT_COMMAND_LIST_COL_CLICK,
wxEVT_COMMAND_LIST_ITEM_ACTIVATED,
/* Tab and notebook control event types */
wxEVT_COMMAND_TAB_SEL_CHANGED,
wxEVT_COMMAND_TAB_SEL_CHANGING,
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING,
/* splitter window */
wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING,
wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED,
wxEVT_COMMAND_SPLITTER_UNSPLIT,
wxEVT_COMMAND_SPLITTER_DOUBLECLICKED,
};
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.14 1999/05/02 02:06:15 RD
// More for wxPython 2.0b9 (hopefully the last...)
//
// Revision 1.13 1999/04/30 03:29:18 RD
//
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.12.4.2 1999/03/28 06:35:01 RD
//
// wxPython 2.0b8
// Python thread support
// various minor additions
// various minor fixes
//
// Revision 1.12.4.1 1999/03/27 23:29:13 RD
//
// wxPython 2.0b8
// Python thread support
// various minor additions
// various minor fixes
//
// Revision 1.12 1999/02/27 04:21:58 RD
//
// Added missing wxRA_SPECIFY_ROWS, wxRA_SPECIFY_COLS
//
// Revision 1.11 1999/02/20 09:02:54 RD
// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
// window handle. If you can get the window handle into the python code,
// it should just work... More news on this later.
//
// Added wxImageList, wxToolTip.
//
// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
// wxRegConfig class.
//
// As usual, some bug fixes, tweaks, etc.
//
// Revision 1.10 1999/01/30 07:30:08 RD
//
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
//
// Various cleanup, tweaks, minor additions, etc. to maintain
// compatibility with the current wxWindows.
//
// Revision 1.9 1998/12/15 20:41:13 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
// Revision 1.8 1998/11/15 23:03:42 RD
// Removing some ifdef's for wxGTK
//
// Revision 1.7 1998/11/11 03:12:24 RD
//
// Additions for wxTreeCtrl
//
// Revision 1.6 1998/10/20 06:43:53 RD
// New wxTreeCtrl wrappers (untested)
// some changes in helpers
// etc.
//
// Revision 1.5 1998/10/02 06:40:32 RD
//
// Version 0.4 of wxPython for MSW.
//
// Revision 1.4 1998/08/18 19:48:11 RD
// more wxGTK compatibility things.
//
// It builds now but there are serious runtime problems...
//
// Revision 1.3 1998/08/14 23:36:33 RD
// Beginings of wxGTK compatibility
//
// Revision 1.2 1998/08/14 03:16:35 RD
// removed some definitions that got removed from defs.h
//
// Revision 1.1 1998/08/09 08:25:49 RD
// Initial version
//
//
//----------------------------------------------------------------------

103
utils/wxPython/src/_extras.py
View File

@ -29,6 +29,12 @@ def _checkForCallback(obj, name, event, theID=-1):
except: pass
else: obj.Connect(theID, -1, event, cb)
## def _checkClassCallback(obj, name):
## try: cb = getattr(obj, name)
## except: pass
## else: obj._addCallback(name, cb)
def _StdWindowCallbacks(win):
_checkForCallback(win, "OnChar", wxEVT_CHAR)
_checkForCallback(win, "OnSize", wxEVT_SIZE)
@ -137,6 +143,9 @@ def EVT_NAVIGATION_KEY(win, func):
def EVT_IDLE(win, func):
win.Connect(-1, -1, wxEVT_IDLE, func)
def EVT_UPDATE_UI(win, id, func):
win.Connect(id, -1, wxEVT_UPDATE_UI, func)
# Mouse Events
def EVT_LEFT_DOWN(win, func):
@ -508,6 +517,9 @@ def EVT_LIST_SET_INFO(win, id, func):
def EVT_LIST_ITEM_SELECTED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_SELECTED, func)
def EVT_LIST_ITEM_ACTIVATED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_ACTIVATED, func)
def EVT_LIST_ITEM_DESELECTED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_DESELECTED, func)
@ -520,6 +532,19 @@ def EVT_LIST_INSERT_ITEM(win, id, func):
def EVT_LIST_COL_CLICK(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_COL_CLICK, func)
#wxSplitterWindow
def EVT_SPLITTER_SASH_POS_CHANGING(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING, func)
def EVT_SPLITTER_SASH_POS_CHANGED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED, func)
def EVT_SPLITTER_UNSPLIT(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_UNSPLIT, func)
def EVT_SPLITTER_DOUBLECLICKED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_DOUBLECLICKED, func)
#----------------------------------------------------------------------
@ -629,81 +654,3 @@ class wxApp(wxPyApp):
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.12 1999/04/30 03:29:18 RD
# wxPython 2.0b9, first phase (win32)
# Added gobs of stuff, see wxPython/README.txt for details
#
# Revision 1.11.4.2 1999/03/28 06:35:01 RD
#
# wxPython 2.0b8
# Python thread support
# various minor additions
# various minor fixes
#
# Revision 1.11.4.1 1999/03/27 23:29:13 RD
#
# wxPython 2.0b8
# Python thread support
# various minor additions
# various minor fixes
#
# Revision 1.11 1999/02/20 09:02:55 RD
# Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
# window handle. If you can get the window handle into the python code,
# it should just work... More news on this later.
#
# Added wxImageList, wxToolTip.
#
# Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
# wxRegConfig class.
#
# As usual, some bug fixes, tweaks, etc.
#
# Revision 1.10 1999/02/01 00:10:39 RD
#
# Added the missing EVT_LIST_ITEM_SELECTED and friends.
#
# Revision 1.9 1999/01/30 07:30:09 RD
#
# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
#
# Various cleanup, tweaks, minor additions, etc. to maintain
# compatibility with the current wxWindows.
#
# Revision 1.8 1999/01/29 21:13:42 HH
# Added aliases for wxDefaultPosition and wxDefaultSize (from wxPy..) in _extras,
# so that C++ documentation applies.
#
# Revision 1.7 1998/11/25 08:45:21 RD
#
# Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
# Added events for wxGrid
# Other various fixes and additions
#
# Revision 1.6 1998/11/16 00:00:52 RD
# Generic treectrl for wxPython/GTK compiles...
#
# Revision 1.5 1998/10/20 07:38:02 RD
# bug fix
#
# Revision 1.4 1998/10/20 06:43:54 RD
# New wxTreeCtrl wrappers (untested)
# some changes in helpers
# etc.
#
# Revision 1.3 1998/10/02 06:40:33 RD
#
# Version 0.4 of wxPython for MSW.
#
# Revision 1.2 1998/08/18 19:48:12 RD
# more wxGTK compatibility things.
#
# It builds now but there are serious runtime problems...
#
# Revision 1.1 1998/08/09 08:25:49 RD
# Initial version
#
#

167
utils/wxPython/src/cmndlgs.i
View File

@ -17,7 +17,7 @@
#include <wx/colordlg.h>
#include <wx/dirdlg.h>
#include <wx/fontdlg.h>
#include <wx/printdlg.h>
#include <wx/progdlg.h>
%}
//----------------------------------------------------------------------
@ -30,6 +30,7 @@
%import misc.i
%import gdi.i
%import windows.i
%import frames.i
%pragma(python) code = "import wx"
@ -196,99 +197,6 @@ public:
};
//----------------------------------------------------------------------
class wxPageSetupDialogData {
public:
wxPageSetupDialogData();
~wxPageSetupDialogData();
void EnableHelp(bool flag);
void EnableMargins(bool flag);
void EnableOrientation(bool flag);
void EnablePaper(bool flag);
void EnablePrinter(bool flag);
bool GetDefaultMinMargins();
bool GetEnableMargins();
bool GetEnableOrientation();
bool GetEnablePaper();
bool GetEnablePrinter();
bool GetEnableHelp();
bool GetDefaultInfo();
wxPoint GetMarginTopLeft();
wxPoint GetMarginBottomRight();
wxPoint GetMinMarginTopLeft();
wxPoint GetMinMarginBottomRight();
wxPaperSize GetPaperId();
wxSize GetPaperSize();
wxPrintData& GetPrintData();
void SetDefaultInfo(bool flag);
void SetDefaultMinMargins(bool flag);
void SetMarginTopLeft(const wxPoint& pt);
void SetMarginBottomRight(const wxPoint& pt);
void SetMinMarginTopLeft(const wxPoint& pt);
void SetMinMarginBottomRight(const wxPoint& pt);
void SetPaperId(wxPaperSize& id);
void SetPaperSize(const wxSize& size);
void SetPrintData(const wxPrintData& printData);
};
class wxPageSetupDialog : public wxDialog {
public:
wxPageSetupDialog(wxWindow* parent, wxPageSetupDialogData* data = NULL);
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
wxPageSetupDialogData& GetPageSetupData();
int ShowModal();
};
//----------------------------------------------------------------------
class wxPrintDialogData {
public:
wxPrintDialogData();
~wxPrintDialogData();
void EnableHelp(bool flag);
void EnablePageNumbers(bool flag);
void EnablePrintToFile(bool flag);
void EnableSelection(bool flag);
bool GetAllPages();
bool GetCollate();
int GetFromPage();
int GetMaxPage();
int GetMinPage();
int GetNoCopies();
wxPrintData& GetPrintData();
bool GetPrintToFile();
int GetToPage();
void SetCollate(bool flag);
void SetFromPage(int page);
void SetMaxPage(int page);
void SetMinPage(int page);
void SetNoCopies(int n);
void SetPrintData(const wxPrintData& printData);
void SetPrintToFile(bool flag);
void SetSetupDialog(bool flag);
void SetToPage(int page);
};
class wxPrintDialog : public wxDialog {
public:
wxPrintDialog(wxWindow* parent, wxPrintDialogData* data = NULL);
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
wxPrintDialogData& GetPrintDialogData();
%new wxDC* GetPrintDC();
int ShowModal();
};
//----------------------------------------------------------------------
class wxMessageDialog : public wxDialog {
@ -306,64 +214,17 @@ public:
//----------------------------------------------------------------------
class wxProgressDialog : public wxFrame {
public:
wxProgressDialog(const wxString& title,
const wxString& message,
int maximum = 100,
wxWindow* parent = NULL,
int style = wxPD_AUTO_HIDE | wxPD_APP_MODAL );
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.9 1999/04/30 03:29:18 RD
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.8 1998/12/17 14:07:25 RR
//
// Removed minor differences between wxMSW and wxGTK
//
// Revision 1.7 1998/12/15 20:41:14 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
// Revision 1.6 1998/11/25 08:45:22 RD
//
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
// Added events for wxGrid
// Other various fixes and additions
//
// Revision 1.5 1998/11/15 23:03:43 RD
// Removing some ifdef's for wxGTK
//
// Revision 1.4 1998/10/02 06:40:34 RD
//
// Version 0.4 of wxPython for MSW.
//
// Revision 1.3 1998/08/18 19:48:13 RD
// more wxGTK compatibility things.
//
// It builds now but there are serious runtime problems...
//
// Revision 1.2 1998/08/15 07:36:25 RD
// - Moved the header in the .i files out of the code that gets put into
// the .cpp files. It caused CVS conflicts because of the RCS ID being
// different each time.
//
// - A few minor fixes.
//
// Revision 1.1 1998/08/09 08:25:49 RD
// Initial version
//
//
bool Update(int value = -1, const char* newmsg = NULL);
void Resume();
}
//----------------------------------------------------------------------

32
utils/wxPython/src/controls.i
View File

@ -26,7 +26,9 @@
#ifdef __WXGTK__
#include <wx/checklst.h>
#include <wx/statline.h>
#endif
%}
//----------------------------------------------------------------------
@ -144,7 +146,7 @@ public:
//----------------------------------------------------------------------
class wxComboBox : public wxControl {
class wxComboBox : public wxChoice {
public:
wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
const wxPoint& pos = wxPyDefaultPosition,
@ -178,7 +180,7 @@ public:
// TODO: void SetClientData(const int n, char* data);
void SetInsertionPoint(long pos);
void SetInsertionPointEnd();
void SetSelection(int n, bool select = TRUE);
//void SetSelection(int n, int select = TRUE); **** Just use the one in wxChoice
%name(SetMark)void SetSelection(long from, long to);
void SetValue(const wxString& text);
};
@ -218,6 +220,19 @@ public:
};
//----------------------------------------------------------------------
#ifdef __WXGTK__
class wxStaticLine : public wxControl {
public:
wxStaticLine( wxWindow *parent, wxWindowID id,
const wxPoint &pos = wxPyDefaultPosition,
const wxSize &size = wxPyDefaultSize,
long style = wxLI_HORIZONTAL,
const char* name = wxStaticTextNameStr );
};
#endif
//----------------------------------------------------------------------
class wxStaticText : public wxControl {
@ -430,15 +445,15 @@ public:
void Enable(bool enable);
%name(EnableItem)void Enable(int n, bool enable);
int FindString(const wxString& string);
#ifdef __WXMSW__
wxString GetLabel();
#endif
//*** wxString GetLabel();
//*** void SetLabel(const wxString& label);
%name(GetItemLabel)wxString GetLabel(int n);
int GetSelection();
wxString GetString(int n);
wxString GetStringSelection();
int Number();
void SetLabel(const wxString& label);
%name(SetItemLabel)void SetLabel(int n, const wxString& label);
void SetSelection(int n);
void SetStringSelection(const wxString& string);
@ -506,7 +521,12 @@ public:
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.14 1999/06/22 07:03:02 RD
// wxPython 2.1b1 for wxMSW (wxGTK coming soon)
// Lots of changes, see the README.txt for details...
//
// Revision 1.13 1999/04/30 21:13:43 RD
//
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//

119
utils/wxPython/src/controls2.i
View File

@ -47,6 +47,7 @@ enum {
wxLIST_MASK_DATA,
wxLIST_MASK_WIDTH,
wxLIST_MASK_FORMAT,
wxLIST_MASK_STATE,
wxLIST_STATE_DONTCARE,
wxLIST_STATE_DROPHILITED,
wxLIST_STATE_FOCUSED,
@ -227,7 +228,7 @@ class wxTreeItemId {
public:
wxTreeItemId();
~wxTreeItemId();
bool IsOk() const { return m_itemId != 0; }
bool IsOk();
};
@ -244,7 +245,13 @@ public:
}
~wxPyTreeItemData() {
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(wxPyEventThreadState);
#endif
Py_DECREF(m_obj);
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
#endif
}
PyObject* GetData() {
@ -367,6 +374,8 @@ public:
wxTreeItemId GetSelection();
wxTreeItemId GetParent(const wxTreeItemId& item);
size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = TRUE);
wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& INOUT);
wxTreeItemId GetNextChild(const wxTreeItemId& item, long& INOUT);
wxTreeItemId GetNextSibling(const wxTreeItemId& item);
@ -429,7 +438,7 @@ public:
val1.thisown = 1
return (val1,val2)
def GetNextChild(self,arg0,arg1):
val1, val2 = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
val1, val2 = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
val1 = wxTreeItemIdPtr(val1)
val1.thisown = 1
return (val1,val2)
@ -494,109 +503,3 @@ public:
//----------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.18 1999/05/02 02:06:15 RD
// More for wxPython 2.0b9 (hopefully the last...)
//
// Revision 1.17 1999/04/30 03:29:18 RD
//
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.16 1999/02/25 07:08:32 RD
//
// wxPython version 2.0b5
//
// Revision 1.15 1999/02/20 09:02:56 RD
// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
// window handle. If you can get the window handle into the python code,
// it should just work... More news on this later.
//
// Added wxImageList, wxToolTip.
//
// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
// wxRegConfig class.
//
// As usual, some bug fixes, tweaks, etc.
//
// Revision 1.14 1999/01/30 07:30:10 RD
//
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
//
// Various cleanup, tweaks, minor additions, etc. to maintain
// compatibility with the current wxWindows.
//
// Revision 1.13 1998/12/17 14:07:34 RR
//
// Removed minor differences between wxMSW and wxGTK
//
// Revision 1.12 1998/12/16 22:10:52 RD
//
// Tweaks needed to be able to build wxPython with wxGTK.
//
// Revision 1.11 1998/12/15 20:41:16 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
// Revision 1.10 1998/11/25 08:45:23 RD
//
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
// Added events for wxGrid
// Other various fixes and additions
//
// Revision 1.9 1998/11/16 00:00:54 RD
// Generic treectrl for wxPython/GTK compiles...
//
// Revision 1.8 1998/11/11 04:40:20 RD
// wxTreeCtrl now works (sort of) for wxPython-GTK. This is the new
// TreeCtrl in src/gtk/treectrl.cpp not the old generic one.
//
// Revision 1.7 1998/11/11 03:12:25 RD
//
// Additions for wxTreeCtrl
//
// Revision 1.6 1998/10/20 06:43:55 RD
// New wxTreeCtrl wrappers (untested)
// some changes in helpers
// etc.
//
// Revision 1.5 1998/10/07 07:34:33 RD
// Version 0.4.1 for wxGTK
//
// Revision 1.4 1998/10/02 06:40:36 RD
//
// Version 0.4 of wxPython for MSW.
//
// Revision 1.3 1998/08/18 19:48:15 RD
// more wxGTK compatibility things.
//
// It builds now but there are serious runtime problems...
//
// Revision 1.2 1998/08/15 07:36:30 RD
// - Moved the header in the .i files out of the code that gets put into
// the .cpp files. It caused CVS conflicts because of the RCS ID being
// different each time.
//
// - A few minor fixes.
//
// Revision 1.1 1998/08/09 08:25:49 RD
// Initial version
//
//

77
utils/wxPython/src/events.i
View File

@ -302,72 +302,13 @@ public:
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.8 1999/04/30 03:29:18 RD
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.7.4.1 1999/03/27 23:29:14 RD
//
// wxPython 2.0b8
// Python thread support
// various minor additions
// various minor fixes
//
// Revision 1.7 1999/02/20 09:02:57 RD
// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
// window handle. If you can get the window handle into the python code,
// it should just work... More news on this later.
//
// Added wxImageList, wxToolTip.
//
// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
// wxRegConfig class.
//
// As usual, some bug fixes, tweaks, etc.
//
// Revision 1.6 1999/02/06 22:55:00 RD
//
// Follow up for changes in wxWindows to various event classes
//
// Revision 1.5 1998/12/15 20:41:17 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
// Revision 1.4 1998/11/16 00:00:55 RD
// Generic treectrl for wxPython/GTK compiles...
//
// Revision 1.3 1998/10/20 06:43:56 RD
// New wxTreeCtrl wrappers (untested)
// some changes in helpers
// etc.
//
// Revision 1.2 1998/08/15 07:36:33 RD
// - Moved the header in the .i files out of the code that gets put into
// the .cpp files. It caused CVS conflicts because of the RCS ID being
// different each time.
//
// - A few minor fixes.
//
// Revision 1.1 1998/08/09 08:25:50 RD
// Initial version
//
//
class wxNotifyEvent : public wxCommandEvent {
public:
bool IsAllowed();
void Veto();
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

4
utils/wxPython/src/gdi.i
View File

@ -273,6 +273,7 @@ public:
long DeviceToLogicalY(long y);
long DeviceToLogicalYRel(long y);
void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
void DrawCircle(long x, long y, long radius);
void DrawEllipse(long x, long y, long width, long height);
void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
void DrawIcon(const wxIcon& icon, long x, long y);
@ -307,7 +308,8 @@ public:
return wc;
}
}
void GetSize(int* OUTPUT, int* OUTPUT); //void GetSize(long* OUTPUT, long* OUTPUT);
%name(GetSizeTuple)void GetSize(int* OUTPUT, int* OUTPUT);
wxSize GetSize();
wxColour& GetTextBackground();
void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT);
%name(GetFullTextExtent)void GetTextExtent(const wxString& string,

34
utils/wxPython/src/glcanvas.i
View File

@ -51,23 +51,24 @@ class wxPalette;
class wxWindow;
class wxSize;
class wxPoint;
class wxGLCanvas;
//---------------------------------------------------------------------------
class wxGLContext {
public:
wxGLContext(bool isRGB, wxWindow *win, const wxPalette& palette = wxNullPalette);
wxGLContext(bool isRGB, wxGLCanvas *win, const wxPalette& palette = wxNullPalette);
~wxGLContext();
void SetCurrent();
void SetColour(const char *colour);
void SwapBuffers();
void SetupPixelFormat();
void SetupPalette(const wxPalette& palette);
wxPalette CreateDefaultPalette();
// void SetupPixelFormat();
// void SetupPalette(const wxPalette& palette);
// wxPalette CreateDefaultPalette();
wxPalette* GetPalette();
// wxPalette* GetPalette();
wxWindow* GetWindow();
};
@ -1089,16 +1090,13 @@ void glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *poi
void glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.2 1999/05/01 04:40:57 RD
// wxPython 2.0b9, second phase (gtk)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.1 1999/04/30 03:29:18 RD
//
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
//
%init %{
wxClassInfo::CleanUpClasses();
wxClassInfo::InitializeClasses();
%}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

268
utils/wxPython/src/helpers.cpp
View File

@ -150,7 +150,8 @@ void __wxPreStart()
#ifdef WXP_WITH_THREAD
static PyThreadState *event_tstate = NULL;
PyThreadState* wxPyEventThreadState = NULL;
bool wxPyInEvent = false;
#endif
static char* __nullArgv[1] = { 0 };
@ -163,7 +164,7 @@ PyObject* __wxStart(PyObject* /* self */, PyObject* args)
long bResult;
#ifdef WXP_WITH_THREAD
event_tstate = PyThreadState_Get();
wxPyEventThreadState = PyThreadState_Get();
#endif
if (!PyArg_ParseTuple(args, "O", &onInitFunc))
@ -288,13 +289,15 @@ wxPyCallback::wxPyCallback(PyObject* func) {
wxPyCallback::~wxPyCallback() {
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(event_tstate);
//if (! wxPyInEvent)
PyEval_RestoreThread(wxPyEventThreadState);
#endif
Py_DECREF(m_func);
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
//if (! wxPyInEvent)
PyEval_SaveThread();
#endif
}
@ -311,7 +314,8 @@ void wxPyCallback::EventThunker(wxEvent& event) {
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(event_tstate);
PyEval_RestoreThread(wxPyEventThreadState);
wxPyInEvent = true;
#endif
arg = wxPyConstructObject((void*)&event, event.GetClassInfo()->GetClassName());
@ -327,6 +331,7 @@ void wxPyCallback::EventThunker(wxEvent& event) {
}
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
wxPyInEvent = false;
#endif
}
@ -343,32 +348,51 @@ wxPyMenu::wxPyMenu(const wxString& title, PyObject* _func)
}
wxPyMenu::~wxPyMenu() {
#ifdef WXP_WITH_THREAD
//if (! wxPyInEvent)
PyEval_RestoreThread(wxPyEventThreadState);
#endif
if (func)
Py_DECREF(func);
#ifdef WXP_WITH_THREAD
//if (! wxPyInEvent)
PyEval_SaveThread();
#endif
}
void wxPyMenu::MenuCallback(wxMenu& menu, wxCommandEvent& evt) {
PyObject* evtobj;
PyObject* menuobj;
PyObject* func;
PyObject* args;
PyObject* res;
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(event_tstate);
PyEval_RestoreThread(wxPyEventThreadState);
wxPyInEvent = true;
#endif
PyObject* evtobj = wxPyConstructObject((void*)&evt, "wxCommandEvent");
PyObject* menuobj = wxPyConstructObject((void*)&menu, "wxMenu");
evtobj = wxPyConstructObject((void*)&evt, "wxCommandEvent");
menuobj = wxPyConstructObject((void*)&menu, "wxMenu");
if (PyErr_Occurred()) {
// bail out if a problem
PyErr_Print();
return;
goto done;
}
// Now call the callback...
PyObject* func = ((wxPyMenu*)&menu)->func;
PyObject* args = PyTuple_New(2);
func = ((wxPyMenu*)&menu)->func;
args = PyTuple_New(2);
PyTuple_SET_ITEM(args, 0, menuobj);
PyTuple_SET_ITEM(args, 1, evtobj);
PyObject* res = PyEval_CallObject(func, args);
res = PyEval_CallObject(func, args);
Py_DECREF(args);
Py_XDECREF(res); /* In case res is a NULL pointer */
done:
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
wxPyInEvent = false;
#endif
}
@ -381,12 +405,23 @@ wxPyTimer::wxPyTimer(PyObject* callback) {
}
wxPyTimer::~wxPyTimer() {
#ifdef WXP_WITH_THREAD
//if (! wxPyInEvent)
PyEval_RestoreThread(wxPyEventThreadState);
#endif
Py_DECREF(func);
#ifdef WXP_WITH_THREAD
//if (! wxPyInEvent)
PyEval_SaveThread();
#endif
}
void wxPyTimer::Notify() {
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(event_tstate);
PyEval_RestoreThread(wxPyEventThreadState);
wxPyInEvent = true;
#endif
PyObject* result;
PyObject* args = Py_BuildValue("()");
@ -401,6 +436,7 @@ void wxPyTimer::Notify() {
}
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
wxPyInEvent = false;
#endif
}
@ -420,10 +456,18 @@ wxPyEvent::wxPyEvent(wxEventType commandType, PyObject* userData)
wxPyEvent::~wxPyEvent() {
#ifdef WXP_WITH_THREAD
//if (! wxPyInEvent)
PyEval_RestoreThread(wxPyEventThreadState);
#endif
if (m_userData != Py_None) {
Py_DECREF(m_userData);
m_userData = Py_None;
}
#ifdef WXP_WITH_THREAD
//if (! wxPyInEvent)
PyEval_SaveThread();
#endif
}
@ -674,129 +718,83 @@ wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source) {
return temp;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
wxPyCallbackHelper::wxPyCallbackHelper() {
m_self = NULL;
m_lastFound = NULL;
}
wxPyCallbackHelper::~wxPyCallbackHelper() {
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(wxPyEventThreadState);
#endif
Py_XDECREF(m_self);
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
#endif
}
void wxPyCallbackHelper::setSelf(PyObject* self) {
m_self = self;
Py_INCREF(m_self);
}
bool wxPyCallbackHelper::findCallback(const wxString& name) {
m_lastFound = NULL;
if (m_self && PyObject_HasAttrString(m_self, (char*)name.c_str()))
m_lastFound = PyObject_GetAttrString(m_self, (char*)name.c_str());
return m_lastFound != NULL;
}
int wxPyCallbackHelper::callCallback(PyObject* argTuple) {
PyObject* result;
int retval = FALSE;
result = callCallbackObj(argTuple);
if (result) { // Assumes an integer return type...
retval = PyInt_AsLong(result);
Py_DECREF(result);
PyErr_Clear(); // forget about it if it's not...
}
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
#endif
return retval;
}
// Invoke the Python callable object, returning the raw PyObject return
// value. Caller should DECREF the return value and also call PyEval_SaveThread.
PyObject* wxPyCallbackHelper::callCallbackObj(PyObject* argTuple) {
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(wxPyEventThreadState);
#endif
PyObject* result;
result = PyEval_CallObject(m_lastFound, argTuple);
Py_DECREF(argTuple);
if (!result) {
PyErr_Print();
}
return result;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.20 1999/04/30 03:29:18 RD
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.19.4.1 1999/03/27 23:29:14 RD
//
// wxPython 2.0b8
// Python thread support
// various minor additions
// various minor fixes
//
// Revision 1.19 1999/02/20 09:02:59 RD
// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
// window handle. If you can get the window handle into the python code,
// it should just work... More news on this later.
//
// Added wxImageList, wxToolTip.
//
// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
// wxRegConfig class.
//
// As usual, some bug fixes, tweaks, etc.
//
// Revision 1.18 1999/01/30 08:17:27 RD
//
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
//
// Various cleanup, tweaks, minor additions, etc. to maintain
// compatibility with the current wxWindows.
//
// Revision 1.17 1999/01/30 07:30:12 RD
//
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
//
// Various cleanup, tweaks, minor additions, etc. to maintain
// compatibility with the current wxWindows.
//
// Revision 1.16 1998/12/17 14:07:39 RR
//
// Removed minor differences between wxMSW and wxGTK
//
// Revision 1.15 1998/12/15 20:41:19 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
// Revision 1.14 1998/11/25 08:45:25 RD
//
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
// Added events for wxGrid
// Other various fixes and additions
//
// Revision 1.13 1998/11/15 23:03:45 RD
// Removing some ifdef's for wxGTK
//
// Revision 1.12 1998/11/03 09:21:08 RD
// fixed a typo
//
// Revision 1.11 1998/10/20 06:43:58 RD
// New wxTreeCtrl wrappers (untested)
// some changes in helpers
// etc.
//
// Revision 1.10 1998/10/02 06:40:39 RD
//
// Version 0.4 of wxPython for MSW.
//
// Revision 1.9 1998/09/25 13:28:52 VZ
//
// USE_xxx constants renamed to wxUSE_xxx. This is an incompatible change, you
// must recompile everything after upgrading!
//
// Revision 1.8 1998/08/27 21:59:08 RD
// Some chicken-and-egg problems solved for wxPython on wxGTK
//
// Revision 1.7 1998/08/27 00:00:26 RD
// - more tweaks
// - have discovered some problems but not yet discovered solutions...
//
// Revision 1.6 1998/08/18 21:54:12 RD
//
// ifdef out some wxGTK specific code
//
// Revision 1.5 1998/08/18 19:48:17 RD
// more wxGTK compatibility things.
//
// It builds now but there are serious runtime problems...
//
// Revision 1.4 1998/08/16 04:31:06 RD
// More wxGTK work.
//
// Revision 1.3 1998/08/15 07:36:36 RD
// - Moved the header in the .i files out of the code that gets put into
// the .cpp files. It caused CVS conflicts because of the RCS ID being
// different each time.
//
// - A few minor fixes.
//
// Revision 1.2 1998/08/14 23:36:36 RD
// Beginings of wxGTK compatibility
//
// Revision 1.1 1998/08/09 08:25:51 RD
// Initial version
//
//

131
utils/wxPython/src/helpers.h
View File

@ -31,6 +31,10 @@
#define wxPy_END_ALLOW_THREADS
#endif
#ifdef WXP_WITH_THREAD
extern PyThreadState* wxPyEventThreadState;
extern bool wxPyInEvent;
#endif
//----------------------------------------------------------------------
@ -133,44 +137,97 @@ private:
PyObject* m_userData;
};
//---------------------------------------------------------------------------
// This class holds an instance of a Python Shadow Class object and assists
// with looking up and invoking Python callback methods from C++ virtual
// method redirections. For all classes which have virtuals which should be
// overridable in wxPython, a new subclass is created that contains a
// wxPyCallbackList. This list is used to hold references to the Python
// methods.
//---------------------------------------------------------------------------
class wxPyCallbackHelper {
public:
wxPyCallbackHelper();
~wxPyCallbackHelper();
void setSelf(PyObject* self);
bool findCallback(const wxString& name);
int callCallback(PyObject* argTuple);
PyObject* callCallbackObj(PyObject* argTuple);
private:
PyObject* m_self;
PyObject* m_lastFound;
};
//---------------------------------------------------------------------------
// These macros are used to implement the virtual methods that should
// redirect to a Python method if one exists. The names designate the
// return type, if any as well as any parameter types.
//---------------------------------------------------------------------------
#define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
bool CBNAME(int a, int b) { \
if (m_myInst.findCallback(#CBNAME)) \
return m_myInst.callCallback(Py_BuildValue("(ii)",a,b)); \
else \
return PCLASS::CBNAME(a,b); \
} \
bool base_##CBNAME(int a, int b) { \
return PCLASS::CBNAME(a,b); \
}
//---------------------------------------------------------------------------
#define PYCALLBACK_BOOL_INT(PCLASS, CBNAME) \
bool CBNAME(int a) { \
if (m_myInst.findCallback(#CBNAME)) \
return m_myInst.callCallback(Py_BuildValue("(i)",a)); \
else \
return PCLASS::CBNAME(a); \
} \
bool base_##CBNAME(int a) { \
return PCLASS::CBNAME(a); \
}
#define PYCALLBACK_BOOL_INT_pure(PCLASS, CBNAME) \
bool CBNAME(int a) { \
if (m_myInst.findCallback(#CBNAME)) \
return m_myInst.callCallback(Py_BuildValue("(i)",a)); \
else return false; \
}
//---------------------------------------------------------------------------
#define PYCALLBACK__(PCLASS, CBNAME) \
void CBNAME() { \
if (m_myInst.findCallback(#CBNAME)) \
m_myInst.callCallback(Py_BuildValue("()")); \
else \
PCLASS::CBNAME(); \
} \
void base_##CBNAME() { \
PCLASS::CBNAME(); \
}
//---------------------------------------------------------------------------
#define PYPRIVATE \
void _setSelf(PyObject* self) { \
m_myInst.setSelf(self); \
} \
private: wxPyCallbackHelper m_myInst;
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.7 1999/04/30 03:29:18 RD
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.6.4.1 1999/03/27 23:29:14 RD
//
// wxPython 2.0b8
// Python thread support
// various minor additions
// various minor fixes
//
// Revision 1.6 1998/11/25 08:45:26 RD
//
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
// Added events for wxGrid
// Other various fixes and additions
//
// Revision 1.5 1998/10/02 06:40:40 RD
//
// Version 0.4 of wxPython for MSW.
//
// Revision 1.4 1998/08/27 21:59:09 RD
// Some chicken-and-egg problems solved for wxPython on wxGTK
//
// Revision 1.3 1998/08/16 04:31:09 RD
// More wxGTK work.
//
// Revision 1.2 1998/08/14 23:36:37 RD
// Beginings of wxGTK compatibility
//
// Revision 1.1 1998/08/09 08:25:51 RD
// Initial version
//
//
#endif

20
utils/wxPython/src/makefile.vc
View File

@ -9,7 +9,7 @@
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
VERSION=2.0b9
VERSION=2.1b1
# Set WXDIR to the root wxWindows directory for your system
WXDIR = $(WXWIN)
@ -32,7 +32,7 @@ COMPILEPY=0
# If your wxWindows is built as a DLL, set this to 1. Using 0 or unset
# means that wxWindows will be staticaly linked with wxPython.
#WXUSINGDLL=1
WXUSINGDLL=1
# If you want to compile in code to aquire/release the Python
# Interpreter Lock at the appropriate places
@ -43,7 +43,7 @@ WXP_USE_THREAD=1
WITH_GLCANVAS=1
# (experimental)
SEPARATE=0
SEPARATE=1
#----------------------------------------------------------------------
@ -74,7 +74,7 @@ SWIGFLAGS=-c++ -shadow -python -dnone -D__WXMSW__ $(OTHERSWIGFLAGS)
GENCODEDIR=msw
!include $(WXDIR)\src\ntwxwin.mak
!include $(WXDIR)\src\makevc.env
#----------------------------------------------------------------------
@ -83,7 +83,8 @@ TARGET = wxc
OBJECTS = wx.obj helpers.obj windows.obj events.obj \
misc.obj gdi.obj mdi.obj controls.obj \
controls2.obj windows2.obj cmndlgs.obj stattool.obj \
frames.obj windows3.obj image.obj \
frames.obj windows3.obj image.obj printfw.obj \
misc2.obj \
!if "$(SEPARATE)" == "0"
utils.obj \
!if "$(WITH_GLCANVAS)" == "1"
@ -110,6 +111,7 @@ PYMODULES = $(TARGETDIR)\wx.py $(TARGETDIR)\events.py \
$(TARGETDIR)\stattool.py $(TARGETDIR)\frames.py \
$(TARGETDIR)\windows3.py $(TARGETDIR)\__init__.py \
$(TARGETDIR)\utils.py $(TARGETDIR)\image.py \
$(TARGETDIR)\printfw.py $(TARGETDIR)\misc2.py \
!if "$(WITH_GLCANVAS)" == "1"
$(TARGETDIR)\glcanvas.py
!endif
@ -255,6 +257,7 @@ $(GENCODEDIR)/windows2.cpp $(GENCODEDIR)/windows2.py : windows2.i my_typemap
$(GENCODEDIR)/windows3.cpp $(GENCODEDIR)/windows3.py : windows3.i my_typemaps.i _defs.i
$(GENCODEDIR)/events.cpp $(GENCODEDIR)/events.py : events.i my_typemaps.i _defs.i
$(GENCODEDIR)/misc.cpp $(GENCODEDIR)/misc.py : misc.i my_typemaps.i _defs.i
$(GENCODEDIR)/misc2.cpp $(GENCODEDIR)/misc2.py : misc2.i my_typemaps.i _defs.i
$(GENCODEDIR)/gdi.cpp $(GENCODEDIR)/gdi.py : gdi.i my_typemaps.i _defs.i
$(GENCODEDIR)/mdi.cpp $(GENCODEDIR)/mdi.py : mdi.i my_typemaps.i _defs.i
$(GENCODEDIR)/controls.cpp $(GENCODEDIR)/controls.py : controls.i my_typemaps.i _defs.i
@ -263,6 +266,7 @@ $(GENCODEDIR)/cmndlgs.cpp $(GENCODEDIR)/cmndlgs.py : cmndlgs.i my_typemap
$(GENCODEDIR)/stattool.cpp $(GENCODEDIR)/stattool.py : stattool.i my_typemaps.i _defs.i
$(GENCODEDIR)/frames.cpp $(GENCODEDIR)/frames.py : frames.i my_typemaps.i _defs.i
$(GENCODEDIR)/image.cpp $(GENCODEDIR)/image.py : image.i my_typemaps.i _defs.i
$(GENCODEDIR)/printfw.cpp $(GENCODEDIR)/printfw.py : printfw.i my_typemaps.i _defs.i
!if "$(SEPARATE)" == "1"
$(GENCODEDIR)\utils.cpp $(GENCODEDIR)\utils.py : utils.i my_typemaps.i
@ -286,6 +290,7 @@ $(TARGETDIR)\windows2.py : $(GENCODEDIR)\windows2.py
$(TARGETDIR)\windows3.py : $(GENCODEDIR)\windows3.py
$(TARGETDIR)\events.py : $(GENCODEDIR)\events.py
$(TARGETDIR)\misc.py : $(GENCODEDIR)\misc.py
$(TARGETDIR)\misc2.py : $(GENCODEDIR)\misc2.py
$(TARGETDIR)\gdi.py : $(GENCODEDIR)\gdi.py
$(TARGETDIR)\mdi.py : $(GENCODEDIR)\mdi.py
$(TARGETDIR)\controls.py : $(GENCODEDIR)\controls.py
@ -295,7 +300,8 @@ $(TARGETDIR)\frames.py : $(GENCODEDIR)\frames.py
$(TARGETDIR)\stattool.py : $(GENCODEDIR)\stattool.py
$(TARGETDIR)\__init__.py : __init__.py
$(TARGETDIR)\utils.py : $(GENCODEDIR)\utils.py
$(TARGETDIR)\image.py : $(GENCODEDIR)\utils.py
$(TARGETDIR)\image.py : $(GENCODEDIR)\image.py
$(TARGETDIR)\printfw.py : $(GENCODEDIR)\printfw.py
!if "$(WITH_GLCANVAS)" == "1"
$(TARGETDIR)\glcanvas.py : $(GENCODEDIR)\glcanvas.py
!endif
@ -307,6 +313,7 @@ SOURCES = $(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py \
$(GENCODEDIR)/windows3.cpp $(GENCODEDIR)/windows3.py \
$(GENCODEDIR)/events.cpp $(GENCODEDIR)/events.py \
$(GENCODEDIR)/misc.cpp $(GENCODEDIR)/misc.py \
$(GENCODEDIR)/misc2.cpp $(GENCODEDIR)/misc2.py \
$(GENCODEDIR)/gdi.cpp $(GENCODEDIR)/gdi.py \
$(GENCODEDIR)/mdi.cpp $(GENCODEDIR)/mdi.py \
$(GENCODEDIR)/controls.cpp $(GENCODEDIR)/controls.py \
@ -316,6 +323,7 @@ SOURCES = $(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py \
$(GENCODEDIR)/frames.cpp $(GENCODEDIR)/frames.py \
$(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py \
$(GENCODEDIR)/image.cpp $(GENCODEDIR)/image.py \
$(GENCODEDIR)/printfw.cpp $(GENCODEDIR)/printfw.py \
!if "$(WITH_GLCANVAS)" == "1"
$(GENCODEDIR)/glcanvas.cpp $(GENCODEDIR)/glcanvas.py \
!endif

135
utils/wxPython/src/misc.i
View File

@ -26,8 +26,8 @@
// Import some definitions of other classes, etc.
%import _defs.i
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class wxSize {
@ -42,8 +42,10 @@ public:
void Set(long w, long h);
long GetX();
long GetY();
%name(GetWidth) long GetX();
%name(GetHeight)long GetY();
long GetWidth();
long GetHeight();
void SetWidth(long w);
void SetHeight(long h);
%addmethods {
PyObject* asTuple() {
@ -203,8 +205,6 @@ void wxBell();
void wxDisplaySize(int *OUTPUT, int *OUTPUT);
void wxEndBusyCursor();
long wxExecute(const wxString& command, bool sync = FALSE);
wxWindow * wxFindWindowByLabel(const wxString& label, wxWindow *parent=NULL);
wxWindow * wxFindWindowByName(const wxString& name, wxWindow *parent=NULL);
#ifdef __WXMSW__
wxWindow * wxGetActiveWindow();
long wxGetElapsedTime(bool resetTimer = TRUE);
@ -219,8 +219,10 @@ void wxStartTimer();
int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
#endif
void wxSleep(int secs);
bool wxYield();
bool wxSafeYield();
void wxEnableTopLevelWindows(bool enable);
%inline %{
char* wxGetResource(char *section, char *entry, char *file = NULL) {
@ -384,126 +386,3 @@ public:
};
//---------------------------------------------------------------------------
// wxToolTip
class wxToolTip {
public:
wxToolTip(const wxString &tip);
void SetTip(const wxString& tip);
wxString GetTip();
// *** Not in the "public" interface void SetWindow(wxWindow *win);
wxWindow *GetWindow();
};
%inline %{
void wxToolTip_Enable(bool flag) {
wxToolTip::Enable(flag);
}
void wxToolTip_SetDelay(long milliseconds) {
wxToolTip::SetDelay(milliseconds);
}
%}
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.14 1999/04/30 03:29:19 RD
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.13.4.1 1999/03/27 23:29:15 RD
//
// wxPython 2.0b8
// Python thread support
// various minor additions
// various minor fixes
//
// Revision 1.13 1999/02/25 07:08:34 RD
//
// wxPython version 2.0b5
//
// Revision 1.12 1999/02/20 10:02:37 RD
//
// Changes needed to enable wxGTK compatibility.
//
// Revision 1.11 1999/02/20 09:03:01 RD
// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
// window handle. If you can get the window handle into the python code,
// it should just work... More news on this later.
//
// Added wxImageList, wxToolTip.
//
// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
// wxRegConfig class.
//
// As usual, some bug fixes, tweaks, etc.
//
// Revision 1.10 1999/01/30 07:30:14 RD
//
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
//
// Various cleanup, tweaks, minor additions, etc. to maintain
// compatibility with the current wxWindows.
//
// Revision 1.9 1998/12/16 22:10:55 RD
//
// Tweaks needed to be able to build wxPython with wxGTK.
//
// Revision 1.8 1998/12/15 20:41:22 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
// Revision 1.7 1998/11/25 08:45:27 RD
//
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
// Added events for wxGrid
// Other various fixes and additions
//
// Revision 1.6 1998/11/15 23:03:46 RD
// Removing some ifdef's for wxGTK
//
// Revision 1.5 1998/10/20 06:43:59 RD
// New wxTreeCtrl wrappers (untested)
// some changes in helpers
// etc.
//
// Revision 1.4 1998/08/18 19:48:19 RD
// more wxGTK compatibility things.
//
// It builds now but there are serious runtime problems...
//
// Revision 1.3 1998/08/16 04:31:10 RD
// More wxGTK work.
//
// Revision 1.2 1998/08/15 07:36:41 RD
// - Moved the header in the .i files out of the code that gets put into
// the .cpp files. It caused CVS conflicts because of the RCS ID being
// different each time.
//
// - A few minor fixes.
//
// Revision 1.1 1998/08/09 08:25:51 RD
// Initial version
//
//

64
utils/wxPython/src/misc2.i Normal file
View File

@ -0,0 +1,64 @@
/////////////////////////////////////////////////////////////////////////////
// Name: misc2.i
// Purpose: Definitions of miscelaneous functions and classes that need
// to know about wxWindow. (So they can't be in misc.i or an
// import loop will happen.)
//
// Author: Robin Dunn
//
// Created: 18-June-1999
// RCS-ID: $Id$
// Copyright: (c) 1998 by Total Control Software
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
%module misc2
%{
#include "helpers.h"
#include <wx/resource.h>
#include <wx/tooltip.h>
%}
//----------------------------------------------------------------------
%include typemaps.i
%include my_typemaps.i
// Import some definitions of other classes, etc.
%import _defs.i
%import windows.i
//----------------------------------------------------------------------
wxWindow * wxFindWindowByLabel(const wxString& label, wxWindow *parent=NULL);
wxWindow * wxFindWindowByName(const wxString& name, wxWindow *parent=NULL);
//---------------------------------------------------------------------------
// wxToolTip
class wxToolTip {
public:
wxToolTip(const wxString &tip);
void SetTip(const wxString& tip);
wxString GetTip();
// *** Not in the "public" interface void SetWindow(wxWindow *win);
wxWindow *GetWindow();
};
%inline %{
void wxToolTip_Enable(bool flag) {
wxToolTip::Enable(flag);
}
void wxToolTip_SetDelay(long milliseconds) {
wxToolTip::SetDelay(milliseconds);
}
%}
//----------------------------------------------------------------------
//----------------------------------------------------------------------

2093
utils/wxPython/src/msw/cmndlgs.cpp
View File

File diff suppressed because it is too large Load Diff

285
utils/wxPython/src/msw/cmndlgs.py
View File

@ -6,6 +6,14 @@ from misc import *
from gdi import *
from windows import *
from frames import *
from stattool import *
from controls import *
from events import *
import wx
class wxColourDataPtr :
def __init__(self,this):
@ -318,259 +326,6 @@ class wxFontDialog(wxFontDialogPtr):
class wxPageSetupDialogDataPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self):
if self.thisown == 1 :
cmndlgsc.delete_wxPageSetupDialogData(self.this)
def EnableHelp(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_EnableHelp(self.this,arg0)
return val
def EnableMargins(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_EnableMargins(self.this,arg0)
return val
def EnableOrientation(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_EnableOrientation(self.this,arg0)
return val
def EnablePaper(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_EnablePaper(self.this,arg0)
return val
def EnablePrinter(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_EnablePrinter(self.this,arg0)
return val
def GetDefaultMinMargins(self):
val = cmndlgsc.wxPageSetupDialogData_GetDefaultMinMargins(self.this)
return val
def GetEnableMargins(self):
val = cmndlgsc.wxPageSetupDialogData_GetEnableMargins(self.this)
return val
def GetEnableOrientation(self):
val = cmndlgsc.wxPageSetupDialogData_GetEnableOrientation(self.this)
return val
def GetEnablePaper(self):
val = cmndlgsc.wxPageSetupDialogData_GetEnablePaper(self.this)
return val
def GetEnablePrinter(self):
val = cmndlgsc.wxPageSetupDialogData_GetEnablePrinter(self.this)
return val
def GetEnableHelp(self):
val = cmndlgsc.wxPageSetupDialogData_GetEnableHelp(self.this)
return val
def GetDefaultInfo(self):
val = cmndlgsc.wxPageSetupDialogData_GetDefaultInfo(self.this)
return val
def GetMarginTopLeft(self):
val = cmndlgsc.wxPageSetupDialogData_GetMarginTopLeft(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetMarginBottomRight(self):
val = cmndlgsc.wxPageSetupDialogData_GetMarginBottomRight(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetMinMarginTopLeft(self):
val = cmndlgsc.wxPageSetupDialogData_GetMinMarginTopLeft(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetMinMarginBottomRight(self):
val = cmndlgsc.wxPageSetupDialogData_GetMinMarginBottomRight(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetPaperId(self):
val = cmndlgsc.wxPageSetupDialogData_GetPaperId(self.this)
return val
def GetPaperSize(self):
val = cmndlgsc.wxPageSetupDialogData_GetPaperSize(self.this)
val = wxSizePtr(val)
val.thisown = 1
return val
def GetPrintData(self):
val = cmndlgsc.wxPageSetupDialogData_GetPrintData(self.this)
val = wxPrintDataPtr(val)
return val
def SetDefaultInfo(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetDefaultInfo(self.this,arg0)
return val
def SetDefaultMinMargins(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetDefaultMinMargins(self.this,arg0)
return val
def SetMarginTopLeft(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetMarginTopLeft(self.this,arg0.this)
return val
def SetMarginBottomRight(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetMarginBottomRight(self.this,arg0.this)
return val
def SetMinMarginTopLeft(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetMinMarginTopLeft(self.this,arg0.this)
return val
def SetMinMarginBottomRight(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetMinMarginBottomRight(self.this,arg0.this)
return val
def SetPaperId(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetPaperId(self.this,arg0)
return val
def SetPaperSize(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetPaperSize(self.this,arg0.this)
return val
def SetPrintData(self,arg0):
val = cmndlgsc.wxPageSetupDialogData_SetPrintData(self.this,arg0.this)
return val
def __repr__(self):
return "<C wxPageSetupDialogData instance>"
class wxPageSetupDialogData(wxPageSetupDialogDataPtr):
def __init__(self) :
self.this = cmndlgsc.new_wxPageSetupDialogData()
self.thisown = 1
class wxPageSetupDialogPtr(wxDialogPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def GetPageSetupData(self):
val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this)
val = wxPageSetupDialogDataPtr(val)
return val
def ShowModal(self):
val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this)
return val
def __repr__(self):
return "<C wxPageSetupDialog instance>"
class wxPageSetupDialog(wxPageSetupDialogPtr):
def __init__(self,arg0,*args) :
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
self.this = apply(cmndlgsc.new_wxPageSetupDialog,(arg0.this,)+args)
self.thisown = 1
wx._StdDialogCallbacks(self)
class wxPrintDialogDataPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self):
if self.thisown == 1 :
cmndlgsc.delete_wxPrintDialogData(self.this)
def EnableHelp(self,arg0):
val = cmndlgsc.wxPrintDialogData_EnableHelp(self.this,arg0)
return val
def EnablePageNumbers(self,arg0):
val = cmndlgsc.wxPrintDialogData_EnablePageNumbers(self.this,arg0)
return val
def EnablePrintToFile(self,arg0):
val = cmndlgsc.wxPrintDialogData_EnablePrintToFile(self.this,arg0)
return val
def EnableSelection(self,arg0):
val = cmndlgsc.wxPrintDialogData_EnableSelection(self.this,arg0)
return val
def GetAllPages(self):
val = cmndlgsc.wxPrintDialogData_GetAllPages(self.this)
return val
def GetCollate(self):
val = cmndlgsc.wxPrintDialogData_GetCollate(self.this)
return val
def GetFromPage(self):
val = cmndlgsc.wxPrintDialogData_GetFromPage(self.this)
return val
def GetMaxPage(self):
val = cmndlgsc.wxPrintDialogData_GetMaxPage(self.this)
return val
def GetMinPage(self):
val = cmndlgsc.wxPrintDialogData_GetMinPage(self.this)
return val
def GetNoCopies(self):
val = cmndlgsc.wxPrintDialogData_GetNoCopies(self.this)
return val
def GetPrintData(self):
val = cmndlgsc.wxPrintDialogData_GetPrintData(self.this)
val = wxPrintDataPtr(val)
return val
def GetPrintToFile(self):
val = cmndlgsc.wxPrintDialogData_GetPrintToFile(self.this)
return val
def GetToPage(self):
val = cmndlgsc.wxPrintDialogData_GetToPage(self.this)
return val
def SetCollate(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetCollate(self.this,arg0)
return val
def SetFromPage(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetFromPage(self.this,arg0)
return val
def SetMaxPage(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetMaxPage(self.this,arg0)
return val
def SetMinPage(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetMinPage(self.this,arg0)
return val
def SetNoCopies(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetNoCopies(self.this,arg0)
return val
def SetPrintData(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetPrintData(self.this,arg0.this)
return val
def SetPrintToFile(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetPrintToFile(self.this,arg0)
return val
def SetSetupDialog(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetSetupDialog(self.this,arg0)
return val
def SetToPage(self,arg0):
val = cmndlgsc.wxPrintDialogData_SetToPage(self.this,arg0)
return val
def __repr__(self):
return "<C wxPrintDialogData instance>"
class wxPrintDialogData(wxPrintDialogDataPtr):
def __init__(self) :
self.this = cmndlgsc.new_wxPrintDialogData()
self.thisown = 1
class wxPrintDialogPtr(wxDialogPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def GetPrintDialogData(self):
val = cmndlgsc.wxPrintDialog_GetPrintDialogData(self.this)
val = wxPrintDialogDataPtr(val)
return val
def GetPrintDC(self):
val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this)
val = wxDCPtr(val)
val.thisown = 1
return val
def ShowModal(self):
val = cmndlgsc.wxPrintDialog_ShowModal(self.this)
return val
def __repr__(self):
return "<C wxPrintDialog instance>"
class wxPrintDialog(wxPrintDialogPtr):
def __init__(self,arg0,*args) :
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
self.this = apply(cmndlgsc.new_wxPrintDialog,(arg0.this,)+args)
self.thisown = 1
wx._StdDialogCallbacks(self)
class wxMessageDialogPtr(wxDialogPtr):
def __init__(self,this):
self.this = this
@ -593,6 +348,30 @@ class wxMessageDialog(wxMessageDialogPtr):
class wxProgressDialogPtr(wxFramePtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def Update(self,*args):
val = apply(cmndlgsc.wxProgressDialog_Update,(self.this,)+args)
return val
def Resume(self):
val = cmndlgsc.wxProgressDialog_Resume(self.this)
return val
def __repr__(self):
return "<C wxProgressDialog instance>"
class wxProgressDialog(wxProgressDialogPtr):
def __init__(self,arg0,arg1,*args) :
argl = map(None,args)
try: argl[1] = argl[1].this
except: pass
args = tuple(argl)
self.this = apply(cmndlgsc.new_wxProgressDialog,(arg0,arg1,)+args)
self.thisown = 1
#-------------- FUNCTION WRAPPERS ------------------

130
utils/wxPython/src/msw/controls.cpp
View File

@ -66,8 +66,10 @@ extern PyObject *SWIG_newvarlink(void);
#ifdef __WXGTK__
#include <wx/checklst.h>
#include <wx/statline.h>
#endif
static PyObject* l_output_helper(PyObject* target, PyObject* o) {
PyObject* o2;
if (!target) {
@ -1269,6 +1271,14 @@ static PyObject *_wrap_wxChoice_SetStringSelection(PyObject *self, PyObject *arg
return _resultobj;
}
static void *SwigwxComboBoxTowxChoice(void *ptr) {
wxComboBox *src;
wxChoice *dest;
src = (wxComboBox *) ptr;
dest = (wxChoice *) src;
return (void *) dest;
}
static void *SwigwxComboBoxTowxControl(void *ptr) {
wxComboBox *src;
wxControl *dest;
@ -1880,35 +1890,6 @@ static PyObject *_wrap_wxComboBox_SetInsertionPointEnd(PyObject *self, PyObject
return _resultobj;
}
#define wxComboBox_SetSelection(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetSelection(_swigarg0,_swigarg1))
static PyObject *_wrap_wxComboBox_SetSelection(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxComboBox * _arg0;
int _arg1;
bool _arg2 = (1);
char * _argc0 = 0;
int tempbool2;
self = self;
if(!PyArg_ParseTuple(args,"si|i:wxComboBox_SetSelection",&_argc0,&_arg1,&tempbool2))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxComboBox_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxComboBox_SetSelection. Expected _wxComboBox_p.");
return NULL;
}
}
_arg2 = (bool ) tempbool2;
{
wxPy_BEGIN_ALLOW_THREADS;
wxComboBox_SetSelection(_arg0,_arg1,_arg2);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxComboBox_SetMark(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetSelection(_swigarg0,_swigarg1))
static PyObject *_wrap_wxComboBox_SetMark(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -5150,36 +5131,6 @@ static PyObject *_wrap_wxRadioBox_FindString(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxRadioBox_GetLabel(_swigobj) (_swigobj->GetLabel())
static PyObject *_wrap_wxRadioBox_GetLabel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxString * _result;
wxRadioBox * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxRadioBox_GetLabel",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxRadioBox_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRadioBox_GetLabel. Expected _wxRadioBox_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxString (wxRadioBox_GetLabel(_arg0));
wxPy_END_ALLOW_THREADS;
}{
_resultobj = PyString_FromString(WXSTRINGCAST *(_result));
}
{
delete _result;
}
return _resultobj;
}
#define wxRadioBox_GetItemLabel(_swigobj,_swigarg0) (_swigobj->GetLabel(_swigarg0))
static PyObject *_wrap_wxRadioBox_GetItemLabel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -5322,44 +5273,6 @@ static PyObject *_wrap_wxRadioBox_Number(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxRadioBox_SetLabel(_swigobj,_swigarg0) (_swigobj->SetLabel(_swigarg0))
static PyObject *_wrap_wxRadioBox_SetLabel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxRadioBox * _arg0;
wxString * _arg1;
char * _argc0 = 0;
PyObject * _obj1 = 0;
self = self;
if(!PyArg_ParseTuple(args,"sO:wxRadioBox_SetLabel",&_argc0,&_obj1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxRadioBox_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRadioBox_SetLabel. Expected _wxRadioBox_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;
wxRadioBox_SetLabel(_arg0,*_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
{
if (_obj1)
delete _arg1;
}
return _resultobj;
}
#define wxRadioBox_SetItemLabel(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetLabel(_swigarg0,_swigarg1))
static PyObject *_wrap_wxRadioBox_SetItemLabel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -6260,13 +6173,11 @@ static PyMethodDef controlscMethods[] = {
{ "wxRadioBox_SetStringSelection", _wrap_wxRadioBox_SetStringSelection, 1 },
{ "wxRadioBox_SetSelection", _wrap_wxRadioBox_SetSelection, 1 },
{ "wxRadioBox_SetItemLabel", _wrap_wxRadioBox_SetItemLabel, 1 },
{ "wxRadioBox_SetLabel", _wrap_wxRadioBox_SetLabel, 1 },
{ "wxRadioBox_Number", _wrap_wxRadioBox_Number, 1 },
{ "wxRadioBox_GetStringSelection", _wrap_wxRadioBox_GetStringSelection, 1 },
{ "wxRadioBox_GetString", _wrap_wxRadioBox_GetString, 1 },
{ "wxRadioBox_GetSelection", _wrap_wxRadioBox_GetSelection, 1 },
{ "wxRadioBox_GetItemLabel", _wrap_wxRadioBox_GetItemLabel, 1 },
{ "wxRadioBox_GetLabel", _wrap_wxRadioBox_GetLabel, 1 },
{ "wxRadioBox_FindString", _wrap_wxRadioBox_FindString, 1 },
{ "wxRadioBox_EnableItem", _wrap_wxRadioBox_EnableItem, 1 },
{ "wxRadioBox_Enable", _wrap_wxRadioBox_Enable, 1 },
@ -6358,7 +6269,6 @@ static PyMethodDef controlscMethods[] = {
{ "new_wxGauge", _wrap_new_wxGauge, 1 },
{ "wxComboBox_SetValue", _wrap_wxComboBox_SetValue, 1 },
{ "wxComboBox_SetMark", _wrap_wxComboBox_SetMark, 1 },
{ "wxComboBox_SetSelection", _wrap_wxComboBox_SetSelection, 1 },
{ "wxComboBox_SetInsertionPointEnd", _wrap_wxComboBox_SetInsertionPointEnd, 1 },
{ "wxComboBox_SetInsertionPoint", _wrap_wxComboBox_SetInsertionPoint, 1 },
{ "wxComboBox_Remove", _wrap_wxComboBox_Remove, 1 },
@ -6427,6 +6337,13 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxSlider",SwigwxSliderTowxEvtHandler);
@ -6469,6 +6386,7 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
@ -6476,6 +6394,8 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
SWIG_RegisterMapping("_byte","_unsigned_char",0);
SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0);
SWIG_RegisterMapping("_wxChoice","_class_wxComboBox",SwigwxComboBoxTowxChoice);
SWIG_RegisterMapping("_wxChoice","_wxComboBox",SwigwxComboBoxTowxChoice);
SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
SWIG_RegisterMapping("_long","_wxDash",0);
@ -6488,6 +6408,7 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -6511,6 +6432,7 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -6531,10 +6453,12 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -6556,6 +6480,7 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -6671,6 +6596,7 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_class_wxListBox","_class_wxCheckListBox",SwigwxCheckListBoxTowxListBox);
SWIG_RegisterMapping("_class_wxListBox","_wxCheckListBox",SwigwxCheckListBoxTowxListBox);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -6685,16 +6611,20 @@ SWIGEXPORT(void,initcontrolsc)() {
SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0);
SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
SWIG_RegisterMapping("_class_wxChoice","_class_wxComboBox",SwigwxComboBoxTowxChoice);
SWIG_RegisterMapping("_class_wxChoice","_wxComboBox",SwigwxComboBoxTowxChoice);
SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0);
SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

11
utils/wxPython/src/msw/controls.py
View File

@ -185,7 +185,7 @@ class wxChoice(wxChoicePtr):
class wxComboBoxPtr(wxControlPtr):
class wxComboBoxPtr(wxChoicePtr):
def __init__(self,this):
self.this = this
self.thisown = 0
@ -243,9 +243,6 @@ class wxComboBoxPtr(wxControlPtr):
def SetInsertionPointEnd(self):
val = controlsc.wxComboBox_SetInsertionPointEnd(self.this)
return val
def SetSelection(self,arg0,*args):
val = apply(controlsc.wxComboBox_SetSelection,(self.this,arg0,)+args)
return val
def SetMark(self,arg0,arg1):
val = controlsc.wxComboBox_SetMark(self.this,arg0,arg1)
return val
@ -698,9 +695,6 @@ class wxRadioBoxPtr(wxControlPtr):
def FindString(self,arg0):
val = controlsc.wxRadioBox_FindString(self.this,arg0)
return val
def GetLabel(self):
val = controlsc.wxRadioBox_GetLabel(self.this)
return val
def GetItemLabel(self,arg0):
val = controlsc.wxRadioBox_GetItemLabel(self.this,arg0)
return val
@ -716,9 +710,6 @@ class wxRadioBoxPtr(wxControlPtr):
def Number(self):
val = controlsc.wxRadioBox_Number(self.this)
return val
def SetLabel(self,arg0):
val = controlsc.wxRadioBox_SetLabel(self.this,arg0)
return val
def SetItemLabel(self,arg0,arg1):
val = controlsc.wxRadioBox_SetItemLabel(self.this,arg0,arg1)
return val

60
utils/wxPython/src/msw/controls2.cpp
View File

@ -128,7 +128,13 @@ public:
}
~wxPyTreeItemData() {
#ifdef WXP_WITH_THREAD
PyEval_RestoreThread(wxPyEventThreadState);
#endif
Py_DECREF(m_obj);
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
#endif
}
PyObject* GetData() {
@ -4018,6 +4024,42 @@ static PyObject *_wrap_wxTreeCtrl_GetParent(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxTreeCtrl_GetChildrenCount(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetChildrenCount(_swigarg0,_swigarg1))
static PyObject *_wrap_wxTreeCtrl_GetChildrenCount(PyObject *self, PyObject *args) {
PyObject * _resultobj;
size_t _result;
wxTreeCtrl * _arg0;
wxTreeItemId * _arg1;
bool _arg2 = (1);
char * _argc0 = 0;
char * _argc1 = 0;
int tempbool2;
self = self;
if(!PyArg_ParseTuple(args,"ss|i:wxTreeCtrl_GetChildrenCount",&_argc0,&_argc1,&tempbool2))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxTreeCtrl_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCtrl_GetChildrenCount. Expected _wxTreeCtrl_p.");
return NULL;
}
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxTreeItemId_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCtrl_GetChildrenCount. Expected _wxTreeItemId_p.");
return NULL;
}
}
_arg2 = (bool ) tempbool2;
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (size_t )wxTreeCtrl_GetChildrenCount(_arg0,*_arg1,_arg2);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxTreeCtrl_GetFirstChild(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetFirstChild(_swigarg0,_swigarg1))
static PyObject *_wrap_wxTreeCtrl_GetFirstChild(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -5089,6 +5131,7 @@ static PyMethodDef controls2cMethods[] = {
{ "wxTreeCtrl_GetNextSibling", _wrap_wxTreeCtrl_GetNextSibling, 1 },
{ "wxTreeCtrl_GetNextChild", _wrap_wxTreeCtrl_GetNextChild, 1 },
{ "wxTreeCtrl_GetFirstChild", _wrap_wxTreeCtrl_GetFirstChild, 1 },
{ "wxTreeCtrl_GetChildrenCount", _wrap_wxTreeCtrl_GetChildrenCount, 1 },
{ "wxTreeCtrl_GetParent", _wrap_wxTreeCtrl_GetParent, 1 },
{ "wxTreeCtrl_GetSelection", _wrap_wxTreeCtrl_GetSelection, 1 },
{ "wxTreeCtrl_GetRootItem", _wrap_wxTreeCtrl_GetRootItem, 1 },
@ -5232,6 +5275,7 @@ SWIGEXPORT(void,initcontrols2c)() {
PyDict_SetItemString(d,"wxLIST_MASK_DATA", PyInt_FromLong((long) wxLIST_MASK_DATA));
PyDict_SetItemString(d,"wxLIST_MASK_WIDTH", PyInt_FromLong((long) wxLIST_MASK_WIDTH));
PyDict_SetItemString(d,"wxLIST_MASK_FORMAT", PyInt_FromLong((long) wxLIST_MASK_FORMAT));
PyDict_SetItemString(d,"wxLIST_MASK_STATE", PyInt_FromLong((long) wxLIST_MASK_STATE));
PyDict_SetItemString(d,"wxLIST_STATE_DONTCARE", PyInt_FromLong((long) wxLIST_STATE_DONTCARE));
PyDict_SetItemString(d,"wxLIST_STATE_DROPHILITED", PyInt_FromLong((long) wxLIST_STATE_DROPHILITED));
PyDict_SetItemString(d,"wxLIST_STATE_FOCUSED", PyInt_FromLong((long) wxLIST_STATE_FOCUSED));
@ -5282,6 +5326,13 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxPyTreeItemData","_wxPyTreeItemData",0);
@ -5293,6 +5344,7 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxTreeCtrl","_wxTreeCtrl",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
@ -5314,6 +5366,7 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxListEvent","_class_wxListEvent",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -5337,6 +5390,7 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -5363,11 +5417,13 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
SWIG_RegisterMapping("_wxListItem","_class_wxListItem",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -5390,6 +5446,7 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -5441,6 +5498,7 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_wxControl","_wxListCtrl",SwigwxListCtrlTowxControl);
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -5460,12 +5518,14 @@ SWIGEXPORT(void,initcontrols2c)() {
SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

6
utils/wxPython/src/msw/controls2.py
View File

@ -488,6 +488,9 @@ class wxTreeCtrlPtr(wxControlPtr):
val = wxTreeItemIdPtr(val)
val.thisown = 1
return val
def GetChildrenCount(self,arg0,*args):
val = apply(controls2c.wxTreeCtrl_GetChildrenCount,(self.this,arg0.this,)+args)
return val
def GetFirstChild(self,arg0,arg1):
val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
return val
@ -620,7 +623,7 @@ class wxTreeCtrlPtr(wxControlPtr):
val1.thisown = 1
return (val1,val2)
def GetNextChild(self,arg0,arg1):
val1, val2 = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
val1, val2 = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
val1 = wxTreeItemIdPtr(val1)
val1.thisown = 1
return (val1,val2)
@ -653,6 +656,7 @@ wxLIST_MASK_IMAGE = controls2c.wxLIST_MASK_IMAGE
wxLIST_MASK_DATA = controls2c.wxLIST_MASK_DATA
wxLIST_MASK_WIDTH = controls2c.wxLIST_MASK_WIDTH
wxLIST_MASK_FORMAT = controls2c.wxLIST_MASK_FORMAT
wxLIST_MASK_STATE = controls2c.wxLIST_MASK_STATE
wxLIST_STATE_DONTCARE = controls2c.wxLIST_STATE_DONTCARE
wxLIST_STATE_DROPHILITED = controls2c.wxLIST_STATE_DROPHILITED
wxLIST_STATE_FOCUSED = controls2c.wxLIST_STATE_FOCUSED

92
utils/wxPython/src/msw/events.cpp
View File

@ -3001,7 +3001,75 @@ static PyObject *_wrap_wxPyEvent_GetUserData(PyObject *self, PyObject *args) {
return _resultobj;
}
static void *SwigwxNotifyEventTowxCommandEvent(void *ptr) {
wxNotifyEvent *src;
wxCommandEvent *dest;
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 * _resultobj;
bool _result;
wxNotifyEvent * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxNotifyEvent_IsAllowed",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(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 * _resultobj;
wxNotifyEvent * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxNotifyEvent_Veto",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(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 PyMethodDef eventscMethods[] = {
{ "wxNotifyEvent_Veto", _wrap_wxNotifyEvent_Veto, 1 },
{ "wxNotifyEvent_IsAllowed", _wrap_wxNotifyEvent_IsAllowed, 1 },
{ "wxPyEvent_GetUserData", _wrap_wxPyEvent_GetUserData, 1 },
{ "wxPyEvent_SetUserData", _wrap_wxPyEvent_SetUserData, 1 },
{ "delete_wxPyEvent", _wrap_delete_wxPyEvent, 1 },
@ -3119,6 +3187,8 @@ SWIGEXPORT(void,initeventsc)() {
* (Used by the SWIG pointer type-checker).
*/
SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
SWIG_RegisterMapping("_wxEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_wxNotifyEvent",SwigwxNotifyEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_class_wxPyEvent",SwigwxPyEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_wxPyEvent",SwigwxPyEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_class_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent);
@ -3169,9 +3239,17 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
SWIG_RegisterMapping("_byte","_unsigned_char",0);
@ -3180,6 +3258,7 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0);
SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -3194,10 +3273,13 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
SWIG_RegisterMapping("_uint","_wxWindowID",0);
SWIG_RegisterMapping("_class_wxEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxNotifyEvent",SwigwxNotifyEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_class_wxPyEvent",SwigwxPyEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxPyEvent",SwigwxPyEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_class_wxSysColourChangedEvent",SwigwxSysColourChangedEventTowxEvent);
@ -3246,6 +3328,8 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_class_wxEvent","_wxSizeEvent",SwigwxSizeEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxPyEvent",SwigwxPyEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_wxPyEvent",SwigwxPyEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxSpinEvent",SwigwxSpinEventTowxCommandEvent);
@ -3257,11 +3341,13 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxSpinEvent",SwigwxSpinEventTowxScrollEvent);
SWIG_RegisterMapping("_wxScrollEvent","_wxSpinEvent",SwigwxSpinEventTowxScrollEvent);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -3274,6 +3360,7 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0);
SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0);
SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -3295,6 +3382,7 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0);
SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_unsigned_char","_byte",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -3306,12 +3394,14 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_class_wxScrollEvent","_wxSpinEvent",SwigwxSpinEventTowxScrollEvent);
SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);
@ -3332,6 +3422,8 @@ SWIGEXPORT(void,initeventsc)() {
SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_wxNotifyEvent",SwigwxNotifyEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxPyEvent",SwigwxPyEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_wxPyEvent",SwigwxPyEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxSpinEvent",SwigwxSpinEventTowxCommandEvent);

19
utils/wxPython/src/msw/events.py
View File

@ -628,6 +628,25 @@ class wxPyEvent(wxPyEventPtr):
class wxNotifyEventPtr(wxCommandEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def IsAllowed(self):
val = eventsc.wxNotifyEvent_IsAllowed(self.this)
return val
def Veto(self):
val = eventsc.wxNotifyEvent_Veto(self.this)
return val
def __repr__(self):
return "<C wxNotifyEvent instance>"
class wxNotifyEvent(wxNotifyEventPtr):
def __init__(self,this):
self.this = this
#-------------- FUNCTION WRAPPERS ------------------

16
utils/wxPython/src/msw/frames.cpp
View File

@ -907,6 +907,13 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMiniFrame",SwigwxMiniFrameTowxEvtHandler);
@ -917,6 +924,7 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
@ -936,6 +944,7 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -962,6 +971,7 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -981,11 +991,13 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -1007,6 +1019,7 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -1054,6 +1067,7 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -1075,12 +1089,14 @@ SWIGEXPORT(void,initframesc)() {
SWIG_RegisterMapping("_wxFrame","_class_wxMiniFrame",SwigwxMiniFrameTowxFrame);
SWIG_RegisterMapping("_wxFrame","_wxMiniFrame",SwigwxMiniFrameTowxFrame);
SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

81
utils/wxPython/src/msw/gdi.cpp
View File

@ -3452,6 +3452,34 @@ static PyObject *_wrap_wxDC_DrawArc(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxDC_DrawCircle(_swigobj,_swigarg0,_swigarg1,_swigarg2) (_swigobj->DrawCircle(_swigarg0,_swigarg1,_swigarg2))
static PyObject *_wrap_wxDC_DrawCircle(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxDC * _arg0;
long _arg1;
long _arg2;
long _arg3;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"slll:wxDC_DrawCircle",&_argc0,&_arg1,&_arg2,&_arg3))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxDC_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDC_DrawCircle. Expected _wxDC_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxDC_DrawCircle(_arg0,_arg1,_arg2,_arg3);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxDC_DrawEllipse(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3) (_swigobj->DrawEllipse(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
static PyObject *_wrap_wxDC_DrawEllipse(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -4291,8 +4319,8 @@ static PyObject *_wrap_wxDC_GetPixel(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxDC_GetSize(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetSize(_swigarg0,_swigarg1))
static PyObject *_wrap_wxDC_GetSize(PyObject *self, PyObject *args) {
#define wxDC_GetSizeTuple(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetSize(_swigarg0,_swigarg1))
static PyObject *_wrap_wxDC_GetSizeTuple(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxDC * _arg0;
int * _arg1;
@ -4308,17 +4336,17 @@ static PyObject *_wrap_wxDC_GetSize(PyObject *self, PyObject *args) {
{
_arg2 = &temp0;
}
if(!PyArg_ParseTuple(args,"s:wxDC_GetSize",&_argc0))
if(!PyArg_ParseTuple(args,"s:wxDC_GetSizeTuple",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxDC_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDC_GetSize. Expected _wxDC_p.");
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDC_GetSizeTuple. Expected _wxDC_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxDC_GetSize(_arg0,_arg1,_arg2);
wxDC_GetSizeTuple(_arg0,_arg1,_arg2);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
@ -4336,6 +4364,33 @@ static PyObject *_wrap_wxDC_GetSize(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxDC_GetSize(_swigobj) (_swigobj->GetSize())
static PyObject *_wrap_wxDC_GetSize(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxSize * _result;
wxDC * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxDC_GetSize",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxDC_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDC_GetSize. Expected _wxDC_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxSize (wxDC_GetSize(_arg0));
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
#define wxDC_GetTextBackground(_swigobj) (_swigobj->GetTextBackground())
static PyObject *_wrap_wxDC_GetTextBackground(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -6323,6 +6378,7 @@ static PyMethodDef gdicMethods[] = {
{ "wxDC_GetTextExtent", _wrap_wxDC_GetTextExtent, 1 },
{ "wxDC_GetTextBackground", _wrap_wxDC_GetTextBackground, 1 },
{ "wxDC_GetSize", _wrap_wxDC_GetSize, 1 },
{ "wxDC_GetSizeTuple", _wrap_wxDC_GetSizeTuple, 1 },
{ "wxDC_GetPixel", _wrap_wxDC_GetPixel, 1 },
{ "wxDC_GetPen", _wrap_wxDC_GetPen, 1 },
{ "wxDC_GetOptimization", _wrap_wxDC_GetOptimization, 1 },
@ -6349,6 +6405,7 @@ static PyMethodDef gdicMethods[] = {
{ "wxDC_DrawIcon", _wrap_wxDC_DrawIcon, 1 },
{ "wxDC_DrawEllipticArc", _wrap_wxDC_DrawEllipticArc, 1 },
{ "wxDC_DrawEllipse", _wrap_wxDC_DrawEllipse, 1 },
{ "wxDC_DrawCircle", _wrap_wxDC_DrawCircle, 1 },
{ "wxDC_DrawArc", _wrap_wxDC_DrawArc, 1 },
{ "wxDC_DeviceToLogicalYRel", _wrap_wxDC_DeviceToLogicalYRel, 1 },
{ "wxDC_DeviceToLogicalY", _wrap_wxDC_DeviceToLogicalY, 1 },
@ -6510,6 +6567,13 @@ SWIGEXPORT(void,initgdic)() {
*/
SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
@ -6537,6 +6601,7 @@ SWIGEXPORT(void,initgdic)() {
SWIG_RegisterMapping("_wxDC","_class_wxMemoryDC",SwigwxMemoryDCTowxDC);
SWIG_RegisterMapping("_wxDC","_wxMemoryDC",SwigwxMemoryDCTowxDC);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -6547,6 +6612,7 @@ SWIGEXPORT(void,initgdic)() {
SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -6561,6 +6627,7 @@ SWIGEXPORT(void,initgdic)() {
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -6586,6 +6653,7 @@ SWIGEXPORT(void,initgdic)() {
SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -6611,6 +6679,7 @@ SWIGEXPORT(void,initgdic)() {
SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
SWIG_RegisterMapping("_unsigned_char","_byte",0);
SWIG_RegisterMapping("_class_wxMetaFileDC","_wxMetaFileDC",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -6621,12 +6690,14 @@ SWIGEXPORT(void,initgdic)() {
SWIG_RegisterMapping("_short","_unsigned_short",0);
SWIG_RegisterMapping("_short","_signed_short",0);
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

8
utils/wxPython/src/msw/gdi.py
View File

@ -368,6 +368,9 @@ class wxDCPtr :
def DrawArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
val = gdic.wxDC_DrawArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
return val
def DrawCircle(self,arg0,arg1,arg2):
val = gdic.wxDC_DrawCircle(self.this,arg0,arg1,arg2)
return val
def DrawEllipse(self,arg0,arg1,arg2,arg3):
val = gdic.wxDC_DrawEllipse(self.this,arg0,arg1,arg2,arg3)
return val
@ -464,8 +467,13 @@ class wxDCPtr :
val = wxColourPtr(val)
val.thisown = 1
return val
def GetSizeTuple(self):
val = gdic.wxDC_GetSizeTuple(self.this)
return val
def GetSize(self):
val = gdic.wxDC_GetSize(self.this)
val = wxSizePtr(val)
val.thisown = 1
return val
def GetTextBackground(self):
val = gdic.wxDC_GetTextBackground(self.this)

127
utils/wxPython/src/msw/glcanvas.cpp
View File

@ -7917,7 +7917,7 @@ static PyObject *_wrap_new_wxGLContext(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxGLContext * _result;
bool _arg0;
wxWindow * _arg1;
wxGLCanvas * _arg1;
wxPalette * _arg2 = &wxNullPalette;
int tempbool0;
char * _argc1 = 0;
@ -7929,8 +7929,8 @@ static PyObject *_wrap_new_wxGLContext(PyObject *self, PyObject *args) {
return NULL;
_arg0 = (bool ) tempbool0;
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxGLContext. Expected _wxWindow_p.");
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxGLCanvas_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxGLContext. Expected _wxGLCanvas_p.");
return NULL;
}
}
@ -8051,118 +8051,6 @@ static PyObject *_wrap_wxGLContext_SwapBuffers(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxGLContext_SetupPixelFormat(_swigobj) (_swigobj->SetupPixelFormat())
static PyObject *_wrap_wxGLContext_SetupPixelFormat(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxGLContext * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxGLContext_SetupPixelFormat",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetupPixelFormat. Expected _wxGLContext_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxGLContext_SetupPixelFormat(_arg0);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxGLContext_SetupPalette(_swigobj,_swigarg0) (_swigobj->SetupPalette(_swigarg0))
static PyObject *_wrap_wxGLContext_SetupPalette(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxGLContext * _arg0;
wxPalette * _arg1;
char * _argc0 = 0;
char * _argc1 = 0;
self = self;
if(!PyArg_ParseTuple(args,"ss:wxGLContext_SetupPalette",&_argc0,&_argc1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetupPalette. Expected _wxGLContext_p.");
return NULL;
}
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxPalette_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGLContext_SetupPalette. Expected _wxPalette_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxGLContext_SetupPalette(_arg0,*_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxGLContext_CreateDefaultPalette(_swigobj) (_swigobj->CreateDefaultPalette())
static PyObject *_wrap_wxGLContext_CreateDefaultPalette(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxPalette * _result;
wxGLContext * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxGLContext_CreateDefaultPalette",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_CreateDefaultPalette. Expected _wxGLContext_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxPalette (wxGLContext_CreateDefaultPalette(_arg0));
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (void *) _result,"_wxPalette_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
#define wxGLContext_GetPalette(_swigobj) (_swigobj->GetPalette())
static PyObject *_wrap_wxGLContext_GetPalette(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxPalette * _result;
wxGLContext * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxGLContext_GetPalette",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxGLContext_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_GetPalette. Expected _wxGLContext_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxPalette *)wxGLContext_GetPalette(_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxPalette_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
#define wxGLContext_GetWindow(_swigobj) (_swigobj->GetWindow())
static PyObject *_wrap_wxGLContext_GetWindow(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -8386,10 +8274,6 @@ static PyMethodDef glcanvascMethods[] = {
{ "wxGLCanvas_SetCurrent", _wrap_wxGLCanvas_SetCurrent, 1 },
{ "new_wxGLCanvas", _wrap_new_wxGLCanvas, 1 },
{ "wxGLContext_GetWindow", _wrap_wxGLContext_GetWindow, 1 },
{ "wxGLContext_GetPalette", _wrap_wxGLContext_GetPalette, 1 },
{ "wxGLContext_CreateDefaultPalette", _wrap_wxGLContext_CreateDefaultPalette, 1 },
{ "wxGLContext_SetupPalette", _wrap_wxGLContext_SetupPalette, 1 },
{ "wxGLContext_SetupPixelFormat", _wrap_wxGLContext_SetupPixelFormat, 1 },
{ "wxGLContext_SwapBuffers", _wrap_wxGLContext_SwapBuffers, 1 },
{ "wxGLContext_SetColour", _wrap_wxGLContext_SetColour, 1 },
{ "wxGLContext_SetCurrent", _wrap_wxGLContext_SetCurrent, 1 },
@ -9344,6 +9228,11 @@ SWIGEXPORT(void,initglcanvasc)() {
PyDict_SetItemString(d,"GL_ZERO", PyInt_FromLong((long) GL_ZERO));
PyDict_SetItemString(d,"GL_ZOOM_X", PyInt_FromLong((long) GL_ZOOM_X));
PyDict_SetItemString(d,"GL_ZOOM_Y", PyInt_FromLong((long) GL_ZOOM_Y));
wxClassInfo::CleanUpClasses();
wxClassInfo::InitializeClasses();
/*
* These are the pointer type-equivalency mappings.
* (Used by the SWIG pointer type-checker).

15
utils/wxPython/src/msw/glcanvas.py
View File

@ -43,21 +43,6 @@ class wxGLContextPtr :
def SwapBuffers(self):
val = glcanvasc.wxGLContext_SwapBuffers(self.this)
return val
def SetupPixelFormat(self):
val = glcanvasc.wxGLContext_SetupPixelFormat(self.this)
return val
def SetupPalette(self,arg0):
val = glcanvasc.wxGLContext_SetupPalette(self.this,arg0.this)
return val
def CreateDefaultPalette(self):
val = glcanvasc.wxGLContext_CreateDefaultPalette(self.this)
val = wxPalettePtr(val)
val.thisown = 1
return val
def GetPalette(self):
val = glcanvasc.wxGLContext_GetPalette(self.this)
val = wxPalettePtr(val)
return val
def GetWindow(self):
val = glcanvasc.wxGLContext_GetWindow(self.this)
val = wxWindowPtr(val)

14
utils/wxPython/src/msw/image.cpp
View File

@ -1460,6 +1460,13 @@ SWIGEXPORT(void,initimagec)() {
SWIG_RegisterMapping("_class_wxJPEGHandler","_wxJPEGHandler",0);
SWIG_RegisterMapping("_wxBMPHandler","_class_wxBMPHandler",0);
SWIG_RegisterMapping("_wxImage","_class_wxImage",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_wxGIFHandler","_class_wxGIFHandler",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
@ -1485,6 +1492,7 @@ SWIGEXPORT(void,initimagec)() {
SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_class_wxBMPHandler","_wxBMPHandler",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -1497,6 +1505,7 @@ SWIGEXPORT(void,initimagec)() {
SWIG_RegisterMapping("_class_wxPNGHandler","_wxPNGHandler",0);
SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -1508,6 +1517,7 @@ SWIGEXPORT(void,initimagec)() {
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -1519,6 +1529,7 @@ SWIGEXPORT(void,initimagec)() {
SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -1553,6 +1564,7 @@ SWIGEXPORT(void,initimagec)() {
SWIG_RegisterMapping("_class_wxImageHandler","_wxImageHandler",0);
SWIG_RegisterMapping("_unsigned_char","_byte",0);
SWIG_RegisterMapping("_class_wxMetaFileDC","_wxMetaFileDC",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -1564,12 +1576,14 @@ SWIGEXPORT(void,initimagec)() {
SWIG_RegisterMapping("_short","_signed_short",0);
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_wxJPEGHandler","_class_wxJPEGHandler",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

16
utils/wxPython/src/msw/mdi.cpp
View File

@ -673,6 +673,13 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
@ -685,6 +692,7 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
@ -704,6 +712,7 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -730,6 +739,7 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -749,12 +759,14 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -777,6 +789,7 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -828,6 +841,7 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -851,12 +865,14 @@ SWIGEXPORT(void,initmdic)() {
SWIG_RegisterMapping("_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
SWIG_RegisterMapping("_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

419
utils/wxPython/src/msw/misc.cpp
View File

@ -121,14 +121,6 @@ static char* wxStringErrorMsg = "string type is required for parameter";
wxGetResource(section, entry, &retval, file);
return retval;
}
void wxToolTip_Enable(bool flag) {
wxToolTip::Enable(flag);
}
void wxToolTip_SetDelay(long milliseconds) {
wxToolTip::SetDelay(milliseconds);
}
static PyObject *_wrap_wxFileSelector(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxString * _result;
@ -702,84 +694,6 @@ static PyObject *_wrap_wxExecute(PyObject *self, PyObject *args) {
return _resultobj;
}
static PyObject *_wrap_wxFindWindowByLabel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
wxString * _arg0;
wxWindow * _arg1 = NULL;
PyObject * _obj0 = 0;
char * _argc1 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"O|s:wxFindWindowByLabel",&_obj0,&_argc1))
return NULL;
{
if (!PyString_Check(_obj0)) {
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
return NULL;
}
_arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFindWindowByLabel. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)wxFindWindowByLabel(*_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
{
if (_obj0)
delete _arg0;
}
return _resultobj;
}
static PyObject *_wrap_wxFindWindowByName(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
wxString * _arg0;
wxWindow * _arg1 = NULL;
PyObject * _obj0 = 0;
char * _argc1 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"O|s:wxFindWindowByName",&_obj0,&_argc1))
return NULL;
{
if (!PyString_Check(_obj0)) {
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
return NULL;
}
_arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFindWindowByName. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)wxFindWindowByName(*_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
{
if (_obj0)
delete _arg0;
}
return _resultobj;
}
static PyObject *_wrap_wxGetActiveWindow(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
@ -988,6 +902,23 @@ static PyObject *_wrap_wxGetOsVersion(PyObject *self, PyObject *args) {
return _resultobj;
}
static PyObject *_wrap_wxSleep(PyObject *self, PyObject *args) {
PyObject * _resultobj;
int _arg0;
self = self;
if(!PyArg_ParseTuple(args,"i:wxSleep",&_arg0))
return NULL;
{
wxPy_BEGIN_ALLOW_THREADS;
wxSleep(_arg0);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static PyObject *_wrap_wxYield(PyObject *self, PyObject *args) {
PyObject * _resultobj;
bool _result;
@ -1020,6 +951,25 @@ static PyObject *_wrap_wxSafeYield(PyObject *self, PyObject *args) {
return _resultobj;
}
static PyObject *_wrap_wxEnableTopLevelWindows(PyObject *self, PyObject *args) {
PyObject * _resultobj;
bool _arg0;
int tempbool0;
self = self;
if(!PyArg_ParseTuple(args,"i:wxEnableTopLevelWindows",&tempbool0))
return NULL;
_arg0 = (bool ) tempbool0;
{
wxPy_BEGIN_ALLOW_THREADS;
wxEnableTopLevelWindows(_arg0);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static PyObject *_wrap_wxGetResource(PyObject *self, PyObject *args) {
PyObject * _resultobj;
char * _result;
@ -1222,42 +1172,6 @@ static PyObject *_wrap_wxResourceParseString(PyObject *self, PyObject *args) {
return _resultobj;
}
static PyObject *_wrap_wxToolTip_Enable(PyObject *self, PyObject *args) {
PyObject * _resultobj;
bool _arg0;
int tempbool0;
self = self;
if(!PyArg_ParseTuple(args,"i:wxToolTip_Enable",&tempbool0))
return NULL;
_arg0 = (bool ) tempbool0;
{
wxPy_BEGIN_ALLOW_THREADS;
wxToolTip_Enable(_arg0);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static PyObject *_wrap_wxToolTip_SetDelay(PyObject *self, PyObject *args) {
PyObject * _resultobj;
long _arg0;
self = self;
if(!PyArg_ParseTuple(args,"l:wxToolTip_SetDelay",&_arg0))
return NULL;
{
wxPy_BEGIN_ALLOW_THREADS;
wxToolTip_SetDelay(_arg0);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxSize_x_set(_swigobj,_swigval) (_swigobj->x = _swigval,_swigval)
static PyObject *_wrap_wxSize_x_set(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -1483,6 +1397,108 @@ static PyObject *_wrap_wxSize_GetY(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxSize_GetWidth(_swigobj) (_swigobj->GetWidth())
static PyObject *_wrap_wxSize_GetWidth(PyObject *self, PyObject *args) {
PyObject * _resultobj;
long _result;
wxSize * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxSize_GetWidth",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSize_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_GetWidth. Expected _wxSize_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_GetWidth(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("l",_result);
return _resultobj;
}
#define wxSize_GetHeight(_swigobj) (_swigobj->GetHeight())
static PyObject *_wrap_wxSize_GetHeight(PyObject *self, PyObject *args) {
PyObject * _resultobj;
long _result;
wxSize * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxSize_GetHeight",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSize_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_GetHeight. Expected _wxSize_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (long )wxSize_GetHeight(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("l",_result);
return _resultobj;
}
#define wxSize_SetWidth(_swigobj,_swigarg0) (_swigobj->SetWidth(_swigarg0))
static PyObject *_wrap_wxSize_SetWidth(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxSize * _arg0;
long _arg1;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"sl:wxSize_SetWidth",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSize_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_SetWidth. Expected _wxSize_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSize_SetWidth(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxSize_SetHeight(_swigobj,_swigarg0) (_swigobj->SetHeight(_swigarg0))
static PyObject *_wrap_wxSize_SetHeight(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxSize * _arg0;
long _arg1;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"sl:wxSize_SetHeight",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSize_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSize_SetHeight. Expected _wxSize_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSize_SetHeight(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static PyObject * wxSize_asTuple(wxSize *self) {
PyObject* tup = PyTuple_New(2);
PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
@ -4014,138 +4030,7 @@ static PyObject *_wrap_new_wxAcceleratorTable(PyObject *self, PyObject *args) {
return _resultobj;
}
#define new_wxToolTip(_swigarg0) (new wxToolTip(_swigarg0))
static PyObject *_wrap_new_wxToolTip(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxToolTip * _result;
wxString * _arg0;
PyObject * _obj0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"O:new_wxToolTip",&_obj0))
return NULL;
{
if (!PyString_Check(_obj0)) {
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
return NULL;
}
_arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxToolTip *)new_wxToolTip(*_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p");
_resultobj = Py_BuildValue("s",_ptemp);
{
if (_obj0)
delete _arg0;
}
return _resultobj;
}
#define wxToolTip_SetTip(_swigobj,_swigarg0) (_swigobj->SetTip(_swigarg0))
static PyObject *_wrap_wxToolTip_SetTip(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxToolTip * _arg0;
wxString * _arg1;
char * _argc0 = 0;
PyObject * _obj1 = 0;
self = self;
if(!PyArg_ParseTuple(args,"sO:wxToolTip_SetTip",&_argc0,&_obj1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_SetTip. Expected _wxToolTip_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;
wxToolTip_SetTip(_arg0,*_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
{
if (_obj1)
delete _arg1;
}
return _resultobj;
}
#define wxToolTip_GetTip(_swigobj) (_swigobj->GetTip())
static PyObject *_wrap_wxToolTip_GetTip(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxString * _result;
wxToolTip * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxToolTip_GetTip",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_GetTip. Expected _wxToolTip_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxString (wxToolTip_GetTip(_arg0));
wxPy_END_ALLOW_THREADS;
}{
_resultobj = PyString_FromString(WXSTRINGCAST *(_result));
}
{
delete _result;
}
return _resultobj;
}
#define wxToolTip_GetWindow(_swigobj) (_swigobj->GetWindow())
static PyObject *_wrap_wxToolTip_GetWindow(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
wxToolTip * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxToolTip_GetWindow",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_GetWindow. Expected _wxToolTip_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)wxToolTip_GetWindow(_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
static PyMethodDef misccMethods[] = {
{ "wxToolTip_GetWindow", _wrap_wxToolTip_GetWindow, 1 },
{ "wxToolTip_GetTip", _wrap_wxToolTip_GetTip, 1 },
{ "wxToolTip_SetTip", _wrap_wxToolTip_SetTip, 1 },
{ "new_wxToolTip", _wrap_new_wxToolTip, 1 },
{ "new_wxAcceleratorTable", _wrap_new_wxAcceleratorTable, 1 },
{ "wxAcceleratorEntry_GetCommand", _wrap_wxAcceleratorEntry_GetCommand, 1 },
{ "wxAcceleratorEntry_GetKeyCode", _wrap_wxAcceleratorEntry_GetKeyCode, 1 },
@ -4240,8 +4125,10 @@ static PyMethodDef misccMethods[] = {
{ "wxRealPoint_x_get", _wrap_wxRealPoint_x_get, 1 },
{ "wxRealPoint_x_set", _wrap_wxRealPoint_x_set, 1 },
{ "wxSize_asTuple", _wrap_wxSize_asTuple, 1 },
{ "wxSize_GetHeight", _wrap_wxSize_GetY, 1 },
{ "wxSize_GetWidth", _wrap_wxSize_GetX, 1 },
{ "wxSize_SetHeight", _wrap_wxSize_SetHeight, 1 },
{ "wxSize_SetWidth", _wrap_wxSize_SetWidth, 1 },
{ "wxSize_GetHeight", _wrap_wxSize_GetHeight, 1 },
{ "wxSize_GetWidth", _wrap_wxSize_GetWidth, 1 },
{ "wxSize_GetY", _wrap_wxSize_GetY, 1 },
{ "wxSize_GetX", _wrap_wxSize_GetX, 1 },
{ "wxSize_Set", _wrap_wxSize_Set, 1 },
@ -4255,8 +4142,6 @@ static PyMethodDef misccMethods[] = {
{ "wxSize_y_set", _wrap_wxSize_y_set, 1 },
{ "wxSize_x_get", _wrap_wxSize_x_get, 1 },
{ "wxSize_x_set", _wrap_wxSize_x_set, 1 },
{ "wxToolTip_SetDelay", _wrap_wxToolTip_SetDelay, 1 },
{ "wxToolTip_Enable", _wrap_wxToolTip_Enable, 1 },
{ "wxResourceParseString", _wrap_wxResourceParseString, 1 },
{ "wxResourceParseFile", _wrap_wxResourceParseFile, 1 },
{ "wxResourceParseData", _wrap_wxResourceParseData, 1 },
@ -4267,8 +4152,10 @@ static PyMethodDef misccMethods[] = {
{ "wxResourceClear", _wrap_wxResourceClear, 1 },
{ "wxResourceAddIdentifier", _wrap_wxResourceAddIdentifier, 1 },
{ "wxGetResource", _wrap_wxGetResource, 1 },
{ "wxEnableTopLevelWindows", _wrap_wxEnableTopLevelWindows, 1 },
{ "wxSafeYield", _wrap_wxSafeYield, 1 },
{ "wxYield", _wrap_wxYield, 1 },
{ "wxSleep", _wrap_wxSleep, 1 },
{ "wxGetOsVersion", _wrap_wxGetOsVersion, 1 },
{ "wxStartTimer", _wrap_wxStartTimer, 1 },
{ "wxShell", _wrap_wxShell, 1 },
@ -4278,8 +4165,6 @@ static PyMethodDef misccMethods[] = {
{ "wxGetFreeMemory", _wrap_wxGetFreeMemory, 1 },
{ "wxGetElapsedTime", _wrap_wxGetElapsedTime, 1 },
{ "wxGetActiveWindow", _wrap_wxGetActiveWindow, 1 },
{ "wxFindWindowByName", _wrap_wxFindWindowByName, 1 },
{ "wxFindWindowByLabel", _wrap_wxFindWindowByLabel, 1 },
{ "wxExecute", _wrap_wxExecute, 1 },
{ "wxEndBusyCursor", _wrap_wxEndBusyCursor, 1 },
{ "wxDisplaySize", _wrap_wxDisplaySize, 1 },
@ -4336,19 +4221,26 @@ SWIGEXPORT(void,initmiscc)() {
*/
SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_byte","_unsigned_char",0);
SWIG_RegisterMapping("_long","_unsigned_long",0);
SWIG_RegisterMapping("_long","_signed_long",0);
SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
SWIG_RegisterMapping("_size_t","_uint",0);
SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -4357,6 +4249,7 @@ SWIGEXPORT(void,initmiscc)() {
SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -4365,6 +4258,7 @@ SWIGEXPORT(void,initmiscc)() {
SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -4380,6 +4274,7 @@ SWIGEXPORT(void,initmiscc)() {
SWIG_RegisterMapping("_signed_short","_short",0);
SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_unsigned_char","_byte",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -4387,12 +4282,14 @@ SWIGEXPORT(void,initmiscc)() {
SWIG_RegisterMapping("_short","_WXTYPE",0);
SWIG_RegisterMapping("_short","_unsigned_short",0);
SWIG_RegisterMapping("_short","_signed_short",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

56
utils/wxPython/src/msw/misc.py
View File

@ -22,6 +22,12 @@ class wxSizePtr :
def GetHeight(self):
val = miscc.wxSize_GetHeight(self.this)
return val
def SetWidth(self,arg0):
val = miscc.wxSize_SetWidth(self.this,arg0)
return val
def SetHeight(self,arg0):
val = miscc.wxSize_SetHeight(self.this,arg0)
return val
def asTuple(self):
val = miscc.wxSize_asTuple(self.this)
return val
@ -488,30 +494,6 @@ class wxAcceleratorTable(wxAcceleratorTablePtr):
class wxToolTipPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def SetTip(self,arg0):
val = miscc.wxToolTip_SetTip(self.this,arg0)
return val
def GetTip(self):
val = miscc.wxToolTip_GetTip(self.this)
return val
def GetWindow(self):
val = miscc.wxToolTip_GetWindow(self.this)
val = wxWindowPtr(val)
return val
def __repr__(self):
return "<C wxToolTip instance>"
class wxToolTip(wxToolTipPtr):
def __init__(self,arg0) :
self.this = miscc.new_wxToolTip(arg0)
self.thisown = 1
#-------------- FUNCTION WRAPPERS ------------------
@ -588,24 +570,6 @@ wxEndBusyCursor = miscc.wxEndBusyCursor
wxExecute = miscc.wxExecute
def wxFindWindowByLabel(arg0,*args):
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
val = apply(miscc.wxFindWindowByLabel,(arg0,)+args)
val = wxWindowPtr(val)
return val
def wxFindWindowByName(arg0,*args):
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
val = apply(miscc.wxFindWindowByName,(arg0,)+args)
val = wxWindowPtr(val)
return val
def wxGetActiveWindow():
val = miscc.wxGetActiveWindow()
val = wxWindowPtr(val)
@ -627,10 +591,14 @@ wxStartTimer = miscc.wxStartTimer
wxGetOsVersion = miscc.wxGetOsVersion
wxSleep = miscc.wxSleep
wxYield = miscc.wxYield
wxSafeYield = miscc.wxSafeYield
wxEnableTopLevelWindows = miscc.wxEnableTopLevelWindows
wxGetResource = miscc.wxGetResource
wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
@ -662,10 +630,6 @@ wxResourceParseFile = miscc.wxResourceParseFile
wxResourceParseString = miscc.wxResourceParseString
wxToolTip_Enable = miscc.wxToolTip_Enable
wxToolTip_SetDelay = miscc.wxToolTip_SetDelay
#-------------- VARIABLE WRAPPERS ------------------

533
utils/wxPython/src/msw/misc2.cpp Normal file
View File

@ -0,0 +1,533 @@
/*
* FILE : msw/misc2.cpp
*
* This file was automatically generated by :
* Simplified Wrapper and Interface Generator (SWIG)
* Version 1.1 (Patch 5)
*
* Portions Copyright (c) 1995-1998
* The University of Utah and The Regents of the University of California.
* Permission is granted to distribute this file in any manner provided
* this notice remains intact.
*
* Do not make changes to this file--changes will be lost!
*
*/
#define SWIGCODE
/* Implementation : PYTHON */
#define SWIGPYTHON
#include <string.h>
#include <stdlib.h>
/* Definitions for Windows/Unix exporting */
#if defined(__WIN32__)
# if defined(_MSC_VER)
# define SWIGEXPORT(a,b) __declspec(dllexport) a b
# else
# if defined(__BORLANDC__)
# define SWIGEXPORT(a,b) a _export b
# else
# define SWIGEXPORT(a,b) a b
# endif
# endif
#else
# define SWIGEXPORT(a,b) a b
#endif
#ifdef __cplusplus
extern "C" {
#endif
#include "Python.h"
extern void SWIG_MakePtr(char *, void *, char *);
extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
extern char *SWIG_GetPtr(char *, void **, char *);
extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
extern PyObject *SWIG_newvarlink(void);
#ifdef __cplusplus
}
#endif
#define SWIG_init initmisc2c
#define SWIG_name "misc2c"
#include "helpers.h"
#include <wx/resource.h>
#include <wx/tooltip.h>
static PyObject* l_output_helper(PyObject* target, PyObject* o) {
PyObject* o2;
if (!target) {
target = o;
} else if (target == Py_None) {
Py_DECREF(Py_None);
target = o;
} else {
if (!PyList_Check(target)) {
o2 = target;
target = PyList_New(0);
PyList_Append(target, o2);
Py_XDECREF(o2);
}
PyList_Append(target,o);
Py_XDECREF(o);
}
return target;
}
static PyObject* t_output_helper(PyObject* target, PyObject* o) {
PyObject* o2;
PyObject* o3;
if (!target) {
target = o;
} else if (target == Py_None) {
Py_DECREF(Py_None);
target = o;
} else {
if (!PyTuple_Check(target)) {
o2 = target;
target = PyTuple_New(1);
PyTuple_SetItem(target, 0, o2);
}
o3 = PyTuple_New(1);
PyTuple_SetItem(o3, 0, o);
o2 = target;
target = PySequence_Concat(o2, o3);
Py_DECREF(o2);
Py_DECREF(o3);
}
return target;
}
extern byte* byte_LIST_helper(PyObject* source);
extern int* int_LIST_helper(PyObject* source);
extern long* long_LIST_helper(PyObject* source);
extern char** string_LIST_helper(PyObject* source);
extern wxPoint* wxPoint_LIST_helper(PyObject* source);
extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
extern wxString* wxString_LIST_helper(PyObject* source);
extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
static char* wxStringErrorMsg = "string type is required for parameter";
void wxToolTip_Enable(bool flag) {
wxToolTip::Enable(flag);
}
void wxToolTip_SetDelay(long milliseconds) {
wxToolTip::SetDelay(milliseconds);
}
static PyObject *_wrap_wxFindWindowByLabel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
wxString * _arg0;
wxWindow * _arg1 = NULL;
PyObject * _obj0 = 0;
char * _argc1 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"O|s:wxFindWindowByLabel",&_obj0,&_argc1))
return NULL;
{
if (!PyString_Check(_obj0)) {
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
return NULL;
}
_arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFindWindowByLabel. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)wxFindWindowByLabel(*_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
{
if (_obj0)
delete _arg0;
}
return _resultobj;
}
static PyObject *_wrap_wxFindWindowByName(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
wxString * _arg0;
wxWindow * _arg1 = NULL;
PyObject * _obj0 = 0;
char * _argc1 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"O|s:wxFindWindowByName",&_obj0,&_argc1))
return NULL;
{
if (!PyString_Check(_obj0)) {
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
return NULL;
}
_arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFindWindowByName. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)wxFindWindowByName(*_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
{
if (_obj0)
delete _arg0;
}
return _resultobj;
}
static PyObject *_wrap_wxToolTip_Enable(PyObject *self, PyObject *args) {
PyObject * _resultobj;
bool _arg0;
int tempbool0;
self = self;
if(!PyArg_ParseTuple(args,"i:wxToolTip_Enable",&tempbool0))
return NULL;
_arg0 = (bool ) tempbool0;
{
wxPy_BEGIN_ALLOW_THREADS;
wxToolTip_Enable(_arg0);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static PyObject *_wrap_wxToolTip_SetDelay(PyObject *self, PyObject *args) {
PyObject * _resultobj;
long _arg0;
self = self;
if(!PyArg_ParseTuple(args,"l:wxToolTip_SetDelay",&_arg0))
return NULL;
{
wxPy_BEGIN_ALLOW_THREADS;
wxToolTip_SetDelay(_arg0);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define new_wxToolTip(_swigarg0) (new wxToolTip(_swigarg0))
static PyObject *_wrap_new_wxToolTip(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxToolTip * _result;
wxString * _arg0;
PyObject * _obj0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"O:new_wxToolTip",&_obj0))
return NULL;
{
if (!PyString_Check(_obj0)) {
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
return NULL;
}
_arg0 = new wxString(PyString_AsString(_obj0), PyString_Size(_obj0));
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxToolTip *)new_wxToolTip(*_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxToolTip_p");
_resultobj = Py_BuildValue("s",_ptemp);
{
if (_obj0)
delete _arg0;
}
return _resultobj;
}
#define wxToolTip_SetTip(_swigobj,_swigarg0) (_swigobj->SetTip(_swigarg0))
static PyObject *_wrap_wxToolTip_SetTip(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxToolTip * _arg0;
wxString * _arg1;
char * _argc0 = 0;
PyObject * _obj1 = 0;
self = self;
if(!PyArg_ParseTuple(args,"sO:wxToolTip_SetTip",&_argc0,&_obj1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_SetTip. Expected _wxToolTip_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;
wxToolTip_SetTip(_arg0,*_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
{
if (_obj1)
delete _arg1;
}
return _resultobj;
}
#define wxToolTip_GetTip(_swigobj) (_swigobj->GetTip())
static PyObject *_wrap_wxToolTip_GetTip(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxString * _result;
wxToolTip * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxToolTip_GetTip",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_GetTip. Expected _wxToolTip_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = new wxString (wxToolTip_GetTip(_arg0));
wxPy_END_ALLOW_THREADS;
}{
_resultobj = PyString_FromString(WXSTRINGCAST *(_result));
}
{
delete _result;
}
return _resultobj;
}
#define wxToolTip_GetWindow(_swigobj) (_swigobj->GetWindow())
static PyObject *_wrap_wxToolTip_GetWindow(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
wxToolTip * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxToolTip_GetWindow",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxToolTip_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxToolTip_GetWindow. Expected _wxToolTip_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)wxToolTip_GetWindow(_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
static PyMethodDef misc2cMethods[] = {
{ "wxToolTip_GetWindow", _wrap_wxToolTip_GetWindow, 1 },
{ "wxToolTip_GetTip", _wrap_wxToolTip_GetTip, 1 },
{ "wxToolTip_SetTip", _wrap_wxToolTip_SetTip, 1 },
{ "new_wxToolTip", _wrap_new_wxToolTip, 1 },
{ "wxToolTip_SetDelay", _wrap_wxToolTip_SetDelay, 1 },
{ "wxToolTip_Enable", _wrap_wxToolTip_Enable, 1 },
{ "wxFindWindowByName", _wrap_wxFindWindowByName, 1 },
{ "wxFindWindowByLabel", _wrap_wxFindWindowByLabel, 1 },
{ NULL, NULL }
};
static PyObject *SWIG_globals;
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void,initmisc2c)() {
PyObject *m, *d;
SWIG_globals = SWIG_newvarlink();
m = Py_InitModule("misc2c", misc2cMethods);
d = PyModule_GetDict(m);
/*
* These are the pointer type-equivalency mappings.
* (Used by the SWIG pointer type-checker).
*/
SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
SWIG_RegisterMapping("_byte","_unsigned_char",0);
SWIG_RegisterMapping("_long","_wxDash",0);
SWIG_RegisterMapping("_long","_unsigned_long",0);
SWIG_RegisterMapping("_long","_signed_long",0);
SWIG_RegisterMapping("_wxImageList","_class_wxImageList",0);
SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
SWIG_RegisterMapping("_size_t","_uint",0);
SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
SWIG_RegisterMapping("_wxPrinterDC","_class_wxPrinterDC",0);
SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0);
SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
SWIG_RegisterMapping("_uint","_wxWindowID",0);
SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
SWIG_RegisterMapping("_unsigned_long","_long",0);
SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
SWIG_RegisterMapping("_wxMetaFileDC","_class_wxMetaFileDC",0);
SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
SWIG_RegisterMapping("_WXTYPE","_short",0);
SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
SWIG_RegisterMapping("_unsigned_short","_short",0);
SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
SWIG_RegisterMapping("_signed_short","_short",0);
SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
SWIG_RegisterMapping("_unsigned_char","_byte",0);
SWIG_RegisterMapping("_class_wxMetaFileDC","_wxMetaFileDC",0);
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
SWIG_RegisterMapping("_unsigned_int","_int",0);
SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
SWIG_RegisterMapping("_class_wxPyMenu","_wxPyMenu",0);
SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
SWIG_RegisterMapping("_short","_WXTYPE",0);
SWIG_RegisterMapping("_short","_unsigned_short",0);
SWIG_RegisterMapping("_short","_signed_short",0);
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);
SWIG_RegisterMapping("_int","_wxWindowID",0);
SWIG_RegisterMapping("_int","_unsigned_int",0);
SWIG_RegisterMapping("_int","_signed_int",0);
SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxPrinterDC","_wxPrinterDC",0);
SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
SWIG_RegisterMapping("_wxDash","_long",0);
SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
}

62
utils/wxPython/src/msw/misc2.py Normal file
View File

@ -0,0 +1,62 @@
# This file was created automatically by SWIG.
import misc2c
from windows import *
from misc import *
from gdi import *
class wxToolTipPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def SetTip(self,arg0):
val = misc2c.wxToolTip_SetTip(self.this,arg0)
return val
def GetTip(self):
val = misc2c.wxToolTip_GetTip(self.this)
return val
def GetWindow(self):
val = misc2c.wxToolTip_GetWindow(self.this)
val = wxWindowPtr(val)
return val
def __repr__(self):
return "<C wxToolTip instance>"
class wxToolTip(wxToolTipPtr):
def __init__(self,arg0) :
self.this = misc2c.new_wxToolTip(arg0)
self.thisown = 1
#-------------- FUNCTION WRAPPERS ------------------
def wxFindWindowByLabel(arg0,*args):
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
val = apply(misc2c.wxFindWindowByLabel,(arg0,)+args)
val = wxWindowPtr(val)
return val
def wxFindWindowByName(arg0,*args):
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
val = apply(misc2c.wxFindWindowByName,(arg0,)+args)
val = wxWindowPtr(val)
return val
wxToolTip_Enable = misc2c.wxToolTip_Enable
wxToolTip_SetDelay = misc2c.wxToolTip_SetDelay
#-------------- VARIABLE WRAPPERS ------------------

4302
utils/wxPython/src/msw/printfw.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

551
utils/wxPython/src/msw/printfw.py Normal file
View File

@ -0,0 +1,551 @@
# This file was created automatically by SWIG.
import printfwc
from misc import *
from windows import *
from gdi import *
from cmndlgs import *
from frames import *
from stattool import *
from controls import *
from events import *
import wx
class wxPrintDataPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self):
if self.thisown == 1 :
printfwc.delete_wxPrintData(self.this)
def GetNoCopies(self):
val = printfwc.wxPrintData_GetNoCopies(self.this)
return val
def GetCollate(self):
val = printfwc.wxPrintData_GetCollate(self.this)
return val
def GetOrientation(self):
val = printfwc.wxPrintData_GetOrientation(self.this)
return val
def GetPrinterName(self):
val = printfwc.wxPrintData_GetPrinterName(self.this)
return val
def GetColour(self):
val = printfwc.wxPrintData_GetColour(self.this)
return val
def GetDuplex(self):
val = printfwc.wxPrintData_GetDuplex(self.this)
return val
def GetPaperId(self):
val = printfwc.wxPrintData_GetPaperId(self.this)
return val
def GetPaperSize(self):
val = printfwc.wxPrintData_GetPaperSize(self.this)
val = wxSizePtr(val)
return val
def GetQuality(self):
val = printfwc.wxPrintData_GetQuality(self.this)
return val
def SetNoCopies(self,arg0):
val = printfwc.wxPrintData_SetNoCopies(self.this,arg0)
return val
def SetCollate(self,arg0):
val = printfwc.wxPrintData_SetCollate(self.this,arg0)
return val
def SetOrientation(self,arg0):
val = printfwc.wxPrintData_SetOrientation(self.this,arg0)
return val
def SetPrinterName(self,arg0):
val = printfwc.wxPrintData_SetPrinterName(self.this,arg0)
return val
def SetColour(self,arg0):
val = printfwc.wxPrintData_SetColour(self.this,arg0)
return val
def SetDuplex(self,arg0):
val = printfwc.wxPrintData_SetDuplex(self.this,arg0)
return val
def SetPaperId(self,arg0):
val = printfwc.wxPrintData_SetPaperId(self.this,arg0)
return val
def SetPaperSize(self,arg0):
val = printfwc.wxPrintData_SetPaperSize(self.this,arg0.this)
return val
def SetQuality(self,arg0):
val = printfwc.wxPrintData_SetQuality(self.this,arg0)
return val
def __repr__(self):
return "<C wxPrintData instance>"
class wxPrintData(wxPrintDataPtr):
def __init__(self) :
self.this = printfwc.new_wxPrintData()
self.thisown = 1
class wxPageSetupDialogDataPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self):
if self.thisown == 1 :
printfwc.delete_wxPageSetupDialogData(self.this)
def EnableHelp(self,arg0):
val = printfwc.wxPageSetupDialogData_EnableHelp(self.this,arg0)
return val
def EnableMargins(self,arg0):
val = printfwc.wxPageSetupDialogData_EnableMargins(self.this,arg0)
return val
def EnableOrientation(self,arg0):
val = printfwc.wxPageSetupDialogData_EnableOrientation(self.this,arg0)
return val
def EnablePaper(self,arg0):
val = printfwc.wxPageSetupDialogData_EnablePaper(self.this,arg0)
return val
def EnablePrinter(self,arg0):
val = printfwc.wxPageSetupDialogData_EnablePrinter(self.this,arg0)
return val
def GetDefaultMinMargins(self):
val = printfwc.wxPageSetupDialogData_GetDefaultMinMargins(self.this)
return val
def GetEnableMargins(self):
val = printfwc.wxPageSetupDialogData_GetEnableMargins(self.this)
return val
def GetEnableOrientation(self):
val = printfwc.wxPageSetupDialogData_GetEnableOrientation(self.this)
return val
def GetEnablePaper(self):
val = printfwc.wxPageSetupDialogData_GetEnablePaper(self.this)
return val
def GetEnablePrinter(self):
val = printfwc.wxPageSetupDialogData_GetEnablePrinter(self.this)
return val
def GetEnableHelp(self):
val = printfwc.wxPageSetupDialogData_GetEnableHelp(self.this)
return val
def GetDefaultInfo(self):
val = printfwc.wxPageSetupDialogData_GetDefaultInfo(self.this)
return val
def GetMarginTopLeft(self):
val = printfwc.wxPageSetupDialogData_GetMarginTopLeft(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetMarginBottomRight(self):
val = printfwc.wxPageSetupDialogData_GetMarginBottomRight(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetMinMarginTopLeft(self):
val = printfwc.wxPageSetupDialogData_GetMinMarginTopLeft(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetMinMarginBottomRight(self):
val = printfwc.wxPageSetupDialogData_GetMinMarginBottomRight(self.this)
val = wxPointPtr(val)
val.thisown = 1
return val
def GetPaperId(self):
val = printfwc.wxPageSetupDialogData_GetPaperId(self.this)
return val
def GetPaperSize(self):
val = printfwc.wxPageSetupDialogData_GetPaperSize(self.this)
val = wxSizePtr(val)
val.thisown = 1
return val
def GetPrintData(self):
val = printfwc.wxPageSetupDialogData_GetPrintData(self.this)
val = wxPrintDataPtr(val)
val.thisown = 1
return val
def SetDefaultInfo(self,arg0):
val = printfwc.wxPageSetupDialogData_SetDefaultInfo(self.this,arg0)
return val
def SetDefaultMinMargins(self,arg0):
val = printfwc.wxPageSetupDialogData_SetDefaultMinMargins(self.this,arg0)
return val
def SetMarginTopLeft(self,arg0):
val = printfwc.wxPageSetupDialogData_SetMarginTopLeft(self.this,arg0.this)
return val
def SetMarginBottomRight(self,arg0):
val = printfwc.wxPageSetupDialogData_SetMarginBottomRight(self.this,arg0.this)
return val
def SetMinMarginTopLeft(self,arg0):
val = printfwc.wxPageSetupDialogData_SetMinMarginTopLeft(self.this,arg0.this)
return val
def SetMinMarginBottomRight(self,arg0):
val = printfwc.wxPageSetupDialogData_SetMinMarginBottomRight(self.this,arg0.this)
return val
def SetPaperId(self,arg0):
val = printfwc.wxPageSetupDialogData_SetPaperId(self.this,arg0)
return val
def SetPaperSize(self,arg0):
val = printfwc.wxPageSetupDialogData_SetPaperSize(self.this,arg0.this)
return val
def SetPrintData(self,arg0):
val = printfwc.wxPageSetupDialogData_SetPrintData(self.this,arg0.this)
return val
def __repr__(self):
return "<C wxPageSetupDialogData instance>"
class wxPageSetupDialogData(wxPageSetupDialogDataPtr):
def __init__(self) :
self.this = printfwc.new_wxPageSetupDialogData()
self.thisown = 1
class wxPageSetupDialogPtr(wxDialogPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def GetPageSetupData(self):
val = printfwc.wxPageSetupDialog_GetPageSetupData(self.this)
val = wxPageSetupDialogDataPtr(val)
return val
def ShowModal(self):
val = printfwc.wxPageSetupDialog_ShowModal(self.this)
return val
def __repr__(self):
return "<C wxPageSetupDialog instance>"
class wxPageSetupDialog(wxPageSetupDialogPtr):
def __init__(self,arg0,*args) :
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
self.this = apply(printfwc.new_wxPageSetupDialog,(arg0.this,)+args)
self.thisown = 1
wx._StdDialogCallbacks(self)
class wxPrintDialogDataPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self):
if self.thisown == 1 :
printfwc.delete_wxPrintDialogData(self.this)
def EnableHelp(self,arg0):
val = printfwc.wxPrintDialogData_EnableHelp(self.this,arg0)
return val
def EnablePageNumbers(self,arg0):
val = printfwc.wxPrintDialogData_EnablePageNumbers(self.this,arg0)
return val
def EnablePrintToFile(self,arg0):
val = printfwc.wxPrintDialogData_EnablePrintToFile(self.this,arg0)
return val
def EnableSelection(self,arg0):
val = printfwc.wxPrintDialogData_EnableSelection(self.this,arg0)
return val
def GetAllPages(self):
val = printfwc.wxPrintDialogData_GetAllPages(self.this)
return val
def GetCollate(self):
val = printfwc.wxPrintDialogData_GetCollate(self.this)
return val
def GetFromPage(self):
val = printfwc.wxPrintDialogData_GetFromPage(self.this)
return val
def GetMaxPage(self):
val = printfwc.wxPrintDialogData_GetMaxPage(self.this)
return val
def GetMinPage(self):
val = printfwc.wxPrintDialogData_GetMinPage(self.this)
return val
def GetNoCopies(self):
val = printfwc.wxPrintDialogData_GetNoCopies(self.this)
return val
def GetPrintData(self):
val = printfwc.wxPrintDialogData_GetPrintData(self.this)
val = wxPrintDataPtr(val)
val.thisown = 1
return val
def GetPrintToFile(self):
val = printfwc.wxPrintDialogData_GetPrintToFile(self.this)
return val
def GetToPage(self):
val = printfwc.wxPrintDialogData_GetToPage(self.this)
return val
def SetCollate(self,arg0):
val = printfwc.wxPrintDialogData_SetCollate(self.this,arg0)
return val
def SetFromPage(self,arg0):
val = printfwc.wxPrintDialogData_SetFromPage(self.this,arg0)
return val
def SetMaxPage(self,arg0):
val = printfwc.wxPrintDialogData_SetMaxPage(self.this,arg0)
return val
def SetMinPage(self,arg0):
val = printfwc.wxPrintDialogData_SetMinPage(self.this,arg0)
return val
def SetNoCopies(self,arg0):
val = printfwc.wxPrintDialogData_SetNoCopies(self.this,arg0)
return val
def SetPrintData(self,arg0):
val = printfwc.wxPrintDialogData_SetPrintData(self.this,arg0.this)
return val
def SetPrintToFile(self,arg0):
val = printfwc.wxPrintDialogData_SetPrintToFile(self.this,arg0)
return val
def SetSetupDialog(self,arg0):
val = printfwc.wxPrintDialogData_SetSetupDialog(self.this,arg0)
return val
def SetToPage(self,arg0):
val = printfwc.wxPrintDialogData_SetToPage(self.this,arg0)
return val
def __repr__(self):
return "<C wxPrintDialogData instance>"
class wxPrintDialogData(wxPrintDialogDataPtr):
def __init__(self) :
self.this = printfwc.new_wxPrintDialogData()
self.thisown = 1
class wxPrintDialogPtr(wxDialogPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def GetPrintDialogData(self):
val = printfwc.wxPrintDialog_GetPrintDialogData(self.this)
val = wxPrintDialogDataPtr(val)
return val
def GetPrintDC(self):
val = printfwc.wxPrintDialog_GetPrintDC(self.this)
val = wxDCPtr(val)
val.thisown = 1
return val
def ShowModal(self):
val = printfwc.wxPrintDialog_ShowModal(self.this)
return val
def __repr__(self):
return "<C wxPrintDialog instance>"
class wxPrintDialog(wxPrintDialogPtr):
def __init__(self,arg0,*args) :
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
self.this = apply(printfwc.new_wxPrintDialog,(arg0.this,)+args)
self.thisown = 1
wx._StdDialogCallbacks(self)
class wxPrintoutPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def _setSelf(self,arg0):
val = printfwc.wxPrintout__setSelf(self.this,arg0)
return val
def Destroy(self):
val = printfwc.wxPrintout_Destroy(self.this)
return val
def GetDC(self):
val = printfwc.wxPrintout_GetDC(self.this)
val = wxDCPtr(val)
return val
def GetPageSizeMM(self):
val = printfwc.wxPrintout_GetPageSizeMM(self.this)
return val
def GetPageSizePixels(self):
val = printfwc.wxPrintout_GetPageSizePixels(self.this)
return val
def GetPPIPrinter(self):
val = printfwc.wxPrintout_GetPPIPrinter(self.this)
return val
def GetPPIScreen(self):
val = printfwc.wxPrintout_GetPPIScreen(self.this)
return val
def IsPreview(self):
val = printfwc.wxPrintout_IsPreview(self.this)
return val
def base_OnBeginDocument(self,arg0,arg1):
val = printfwc.wxPrintout_base_OnBeginDocument(self.this,arg0,arg1)
return val
def base_OnEndDocument(self):
val = printfwc.wxPrintout_base_OnEndDocument(self.this)
return val
def base_OnBeginPrinting(self):
val = printfwc.wxPrintout_base_OnBeginPrinting(self.this)
return val
def base_OnEndPrinting(self):
val = printfwc.wxPrintout_base_OnEndPrinting(self.this)
return val
def base_OnPreparePrinting(self):
val = printfwc.wxPrintout_base_OnPreparePrinting(self.this)
return val
def base_GetPageInfo(self):
val = printfwc.wxPrintout_base_GetPageInfo(self.this)
return val
def base_HasPage(self,arg0):
val = printfwc.wxPrintout_base_HasPage(self.this,arg0)
return val
def __repr__(self):
return "<C wxPrintout instance>"
class wxPrintout(wxPrintoutPtr):
def __init__(self,*args) :
self.this = apply(printfwc.new_wxPrintout,()+args)
self.thisown = 1
self._setSelf(self)
class wxPrinterPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def __del__(self):
if self.thisown == 1 :
printfwc.delete_wxPrinter(self.this)
def CreateAbortWindow(self,arg0,arg1):
val = printfwc.wxPrinter_CreateAbortWindow(self.this,arg0.this,arg1.this)
return val
def GetPrintDialogData(self):
val = printfwc.wxPrinter_GetPrintDialogData(self.this)
val = wxPrintDialogDataPtr(val)
return val
def Print(self,arg0,arg1,*args):
val = apply(printfwc.wxPrinter_Print,(self.this,arg0.this,arg1.this,)+args)
return val
def PrintDialog(self,arg0):
val = printfwc.wxPrinter_PrintDialog(self.this,arg0.this)
val = wxDCPtr(val)
return val
def ReportError(self,arg0,arg1,arg2):
val = printfwc.wxPrinter_ReportError(self.this,arg0.this,arg1.this,arg2)
return val
def Setup(self,arg0):
val = printfwc.wxPrinter_Setup(self.this,arg0.this)
return val
def __repr__(self):
return "<C wxPrinter instance>"
class wxPrinter(wxPrinterPtr):
def __init__(self,*args) :
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
self.this = apply(printfwc.new_wxPrinter,()+args)
self.thisown = 1
class wxPrintPreviewPtr :
def __init__(self,this):
self.this = this
self.thisown = 0
def GetCanvas(self):
val = printfwc.wxPrintPreview_GetCanvas(self.this)
val = wxWindowPtr(val)
return val
def GetCurrentPage(self):
val = printfwc.wxPrintPreview_GetCurrentPage(self.this)
return val
def GetFrame(self):
val = printfwc.wxPrintPreview_GetFrame(self.this)
val = wxFramePtr(val)
return val
def GetMaxPage(self):
val = printfwc.wxPrintPreview_GetMaxPage(self.this)
return val
def GetMinPage(self):
val = printfwc.wxPrintPreview_GetMinPage(self.this)
return val
def GetPrintDialogData(self):
val = printfwc.wxPrintPreview_GetPrintDialogData(self.this)
val = wxPrintDialogDataPtr(val)
return val
def GetPrintout(self):
val = printfwc.wxPrintPreview_GetPrintout(self.this)
val = wxPrintoutPtr(val)
return val
def GetPrintoutForPrinting(self):
val = printfwc.wxPrintPreview_GetPrintoutForPrinting(self.this)
val = wxPrintoutPtr(val)
return val
def GetZoom(self):
val = printfwc.wxPrintPreview_GetZoom(self.this)
return val
def Ok(self):
val = printfwc.wxPrintPreview_Ok(self.this)
return val
def Print(self,arg0):
val = printfwc.wxPrintPreview_Print(self.this,arg0)
return val
def SetCanvas(self,arg0):
val = printfwc.wxPrintPreview_SetCanvas(self.this,arg0.this)
return val
def SetCurrentPage(self,arg0):
val = printfwc.wxPrintPreview_SetCurrentPage(self.this,arg0)
return val
def SetFrame(self,arg0):
val = printfwc.wxPrintPreview_SetFrame(self.this,arg0.this)
return val
def SetPrintout(self,arg0):
val = printfwc.wxPrintPreview_SetPrintout(self.this,arg0.this)
return val
def SetZoom(self,arg0):
val = printfwc.wxPrintPreview_SetZoom(self.this,arg0)
return val
def __repr__(self):
return "<C wxPrintPreview instance>"
class wxPrintPreview(wxPrintPreviewPtr):
def __init__(self,arg0,arg1,*args) :
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
args = tuple(argl)
self.this = apply(printfwc.new_wxPrintPreview,(arg0.this,arg1.this,)+args)
self.thisown = 1
class wxPreviewFramePtr(wxFramePtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def Initialize(self):
val = printfwc.wxPreviewFrame_Initialize(self.this)
return val
def __repr__(self):
return "<C wxPreviewFrame instance>"
class wxPreviewFrame(wxPreviewFramePtr):
def __init__(self,arg0,arg1,arg2,*args) :
argl = map(None,args)
try: argl[0] = argl[0].this
except: pass
try: argl[1] = argl[1].this
except: pass
args = tuple(argl)
self.this = apply(printfwc.new_wxPreviewFrame,(arg0.this,arg1.this,arg2,)+args)
self.thisown = 1
wx._StdFrameCallbacks(self)
#-------------- FUNCTION WRAPPERS ------------------
#-------------- VARIABLE WRAPPERS ------------------

16
utils/wxPython/src/msw/stattool.cpp
View File

@ -2367,6 +2367,13 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxToolBar",SwigwxToolBarTowxEvtHandler);
@ -2377,6 +2384,7 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
@ -2396,6 +2404,7 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -2421,6 +2430,7 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -2440,11 +2450,13 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -2466,6 +2478,7 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -2515,6 +2528,7 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_wxControl","_wxToolBar",SwigwxToolBarTowxControl);
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -2533,12 +2547,14 @@ SWIGEXPORT(void,initstattoolc)() {
SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

525
utils/wxPython/src/msw/utils.cpp
View File

@ -21,6 +21,32 @@
#define SWIGPYTHON
#include <string.h>
#include <stdlib.h>
/***********************************************************************
* $Header$
* swig_lib/python/python.cfg
*
* This file contains coded needed to add variable linking to the
* Python interpreter. C variables are added as a new kind of Python
* datatype.
*
* Also contains supporting code for building python under Windows
* and things like that.
*
* $Log$
* Revision 1.6 1999/06/22 07:03:28 RD
* wxPython 2.1b1 for wxMSW (wxGTK coming soon)
* Lots of changes, see the README.txt for details...
*
************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
#include "Python.h"
#ifdef __cplusplus
}
#endif
/* Definitions for Windows/Unix exporting */
#if defined(__WIN32__)
# if defined(_MSC_VER)
@ -36,18 +62,496 @@
# define SWIGEXPORT(a,b) a b
#endif
#ifdef SWIG_GLOBAL
#ifdef __cplusplus
extern "C" {
#define SWIGSTATIC extern "C"
#else
#define SWIGSTATIC
#endif
#include "Python.h"
extern void SWIG_MakePtr(char *, void *, char *);
extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
extern char *SWIG_GetPtr(char *, void **, char *);
extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
extern PyObject *SWIG_newvarlink(void);
#ifdef __cplusplus
#endif
#ifndef SWIGSTATIC
#define SWIGSTATIC static
#endif
typedef struct {
char *name;
PyObject *(*get_attr)(void);
int (*set_attr)(PyObject *);
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar **vars;
int nvars;
int maxvars;
} swig_varlinkobject;
/* ----------------------------------------------------------------------
swig_varlink_repr()
Function for python repr method
---------------------------------------------------------------------- */
static PyObject *
swig_varlink_repr(swig_varlinkobject *v)
{
v = v;
return PyString_FromString("<Global variables>");
}
/* ---------------------------------------------------------------------
swig_varlink_print()
Print out all of the global variable names
--------------------------------------------------------------------- */
static int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags)
{
int i = 0;
flags = flags;
fprintf(fp,"Global variables { ");
while (v->vars[i]) {
fprintf(fp,"%s", v->vars[i]->name);
i++;
if (v->vars[i]) fprintf(fp,", ");
}
fprintf(fp," }\n");
return 0;
}
/* --------------------------------------------------------------------
swig_varlink_getattr
This function gets the value of a variable and returns it as a
PyObject. In our case, we'll be looking at the datatype and
converting into a number or string
-------------------------------------------------------------------- */
static PyObject *
swig_varlink_getattr(swig_varlinkobject *v, char *n)
{
int i = 0;
char temp[128];
while (v->vars[i]) {
if (strcmp(v->vars[i]->name,n) == 0) {
return (*v->vars[i]->get_attr)();
}
i++;
}
sprintf(temp,"C global variable %s not found.", n);
PyErr_SetString(PyExc_NameError,temp);
return NULL;
}
/* -------------------------------------------------------------------
swig_varlink_setattr()
This function sets the value of a variable.
------------------------------------------------------------------- */
static int
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
{
char temp[128];
int i = 0;
while (v->vars[i]) {
if (strcmp(v->vars[i]->name,n) == 0) {
return (*v->vars[i]->set_attr)(p);
}
i++;
}
sprintf(temp,"C global variable %s not found.", n);
PyErr_SetString(PyExc_NameError,temp);
return 1;
}
statichere PyTypeObject varlinktype = {
/* PyObject_HEAD_INIT(&PyType_Type) Note : This doesn't work on some machines */
PyObject_HEAD_INIT(0)
0,
"varlink", /* Type name */
sizeof(swig_varlinkobject), /* Basic size */
0, /* Itemsize */
0, /* Deallocator */
(printfunc) swig_varlink_print, /* Print */
(getattrfunc) swig_varlink_getattr, /* get attr */
(setattrfunc) swig_varlink_setattr, /* Set attr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_mapping*/
0, /* tp_hash */
};
/* Create a variable linking object for use later */
SWIGSTATIC PyObject *
SWIG_newvarlink(void)
{
swig_varlinkobject *result = 0;
result = PyMem_NEW(swig_varlinkobject,1);
varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
result->ob_type = &varlinktype;
/* _Py_NewReference(result); Does not seem to be necessary */
result->nvars = 0;
result->maxvars = 64;
result->vars = (swig_globalvar **) malloc(64*sizeof(swig_globalvar *));
result->vars[0] = 0;
result->ob_refcnt = 0;
Py_XINCREF((PyObject *) result);
return ((PyObject*) result);
}
SWIGSTATIC void
SWIG_addvarlink(PyObject *p, char *name,
PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p))
{
swig_varlinkobject *v;
v= (swig_varlinkobject *) p;
if (v->nvars >= v->maxvars -1) {
v->maxvars = 2*v->maxvars;
v->vars = (swig_globalvar **) realloc(v->vars,v->maxvars*sizeof(swig_globalvar *));
if (v->vars == NULL) {
fprintf(stderr,"SWIG : Fatal error in initializing Python module.\n");
exit(1);
}
}
v->vars[v->nvars] = (swig_globalvar *) malloc(sizeof(swig_globalvar));
v->vars[v->nvars]->name = (char *) malloc(strlen(name)+1);
strcpy(v->vars[v->nvars]->name,name);
v->vars[v->nvars]->get_attr = get_attr;
v->vars[v->nvars]->set_attr = set_attr;
v->nvars++;
v->vars[v->nvars] = 0;
}
/*****************************************************************************
* $Header$
*
* swigptr.swg
*
* This file contains supporting code for the SWIG run-time type checking
* mechanism. The following functions are available :
*
* SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *));
*
* Registers a new type-mapping with the type-checker. origtype is the
* original datatype and newtype is an equivalent type. cast is optional
* pointer to a function to cast pointer values between types (this
* is typically used to cast pointers from derived classes to base classes in C++)
*
* SWIG_MakePtr(char *buffer, void *ptr, char *typestring);
*
* Makes a pointer string from a pointer and typestring. The result is returned
* in buffer which is assumed to hold enough space for the result.
*
* char * SWIG_GetPtr(char *buffer, void **ptr, char *type)
*
* Gets a pointer value from a string. If there is a type-mismatch, returns
* a character string to the received type. On success, returns NULL.
*
*
* You can remap these functions by making a file called "swigptr.swg" in
* your the same directory as the interface file you are wrapping.
*
* These functions are normally declared static, but this file can be
* can be used in a multi-module environment by redefining the symbol
* SWIGSTATIC.
*****************************************************************************/
#include <stdlib.h>
#ifdef SWIG_GLOBAL
#ifdef __cplusplus
#define SWIGSTATIC extern "C"
#else
#define SWIGSTATIC
#endif
#endif
#ifndef SWIGSTATIC
#define SWIGSTATIC static
#endif
/* SWIG pointer structure */
typedef struct SwigPtrType {
char *name; /* Datatype name */
int len; /* Length (used for optimization) */
void *(*cast)(void *); /* Pointer casting function */
struct SwigPtrType *next; /* Linked list pointer */
} SwigPtrType;
/* Pointer cache structure */
typedef struct {
int stat; /* Status (valid) bit */
SwigPtrType *tp; /* Pointer to type structure */
char name[256]; /* Given datatype name */
char mapped[256]; /* Equivalent name */
} SwigCacheType;
/* Some variables */
static int SwigPtrMax = 64; /* Max entries that can be currently held */
/* This value may be adjusted dynamically */
static int SwigPtrN = 0; /* Current number of entries */
static int SwigPtrSort = 0; /* Status flag indicating sort */
static int SwigStart[256]; /* Starting positions of types */
/* Pointer table */
static SwigPtrType *SwigPtrTable = 0; /* Table containing pointer equivalences */
/* Cached values */
#define SWIG_CACHESIZE 8
#define SWIG_CACHEMASK 0x7
static SwigCacheType SwigCache[SWIG_CACHESIZE];
static int SwigCacheIndex = 0;
static int SwigLastCache = 0;
/* Sort comparison function */
static int swigsort(const void *data1, const void *data2) {
SwigPtrType *d1 = (SwigPtrType *) data1;
SwigPtrType *d2 = (SwigPtrType *) data2;
return strcmp(d1->name,d2->name);
}
/* Binary Search function */
static int swigcmp(const void *key, const void *data) {
char *k = (char *) key;
SwigPtrType *d = (SwigPtrType *) data;
return strncmp(k,d->name,d->len);
}
/* Register a new datatype with the type-checker */
SWIGSTATIC
void SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *)) {
int i;
SwigPtrType *t = 0,*t1;
/* Allocate the pointer table if necessary */
if (!SwigPtrTable) {
SwigPtrTable = (SwigPtrType *) malloc(SwigPtrMax*sizeof(SwigPtrType));
SwigPtrN = 0;
}
/* Grow the table */
if (SwigPtrN >= SwigPtrMax) {
SwigPtrMax = 2*SwigPtrMax;
SwigPtrTable = (SwigPtrType *) realloc((char *) SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
}
for (i = 0; i < SwigPtrN; i++)
if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
t = &SwigPtrTable[i];
break;
}
if (!t) {
t = &SwigPtrTable[SwigPtrN];
t->name = origtype;
t->len = strlen(t->name);
t->cast = 0;
t->next = 0;
SwigPtrN++;
}
/* Check for existing entry */
while (t->next) {
if ((strcmp(t->name,newtype) == 0)) {
if (cast) t->cast = cast;
return;
}
t = t->next;
}
/* Now place entry (in sorted order) */
t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
t1->name = newtype;
t1->len = strlen(t1->name);
t1->cast = cast;
t1->next = 0;
t->next = t1;
SwigPtrSort = 0;
}
/* Make a pointer value string */
SWIGSTATIC
void SWIG_MakePtr(char *_c, const void *_ptr, char *type) {
static char _hex[16] =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'};
unsigned long _p, _s;
char _result[20], *_r; /* Note : a 64-bit hex number = 16 digits */
_r = _result;
_p = (unsigned long) _ptr;
if (_p > 0) {
while (_p > 0) {
_s = _p & 0xf;
*(_r++) = _hex[_s];
_p = _p >> 4;
}
*_r = '_';
while (_r >= _result)
*(_c++) = *(_r--);
} else {
strcpy (_c, "NULL");
}
if (_ptr)
strcpy (_c, type);
}
/* Define for backwards compatibility */
#define _swig_make_hex SWIG_MakePtr
/* Function for getting a pointer value */
SWIGSTATIC
char *SWIG_GetPtr(char *_c, void **ptr, char *_t)
{
unsigned long _p;
char temp_type[256];
char *name;
int i, len;
SwigPtrType *sp,*tp;
SwigCacheType *cache;
int start, end;
_p = 0;
/* Pointer values must start with leading underscore */
if (*_c == '_') {
_c++;
/* Extract hex value from pointer */
while (*_c) {
if ((*_c >= '0') && (*_c <= '9'))
_p = (_p << 4) + (*_c - '0');
else if ((*_c >= 'a') && (*_c <= 'f'))
_p = (_p << 4) + ((*_c - 'a') + 10);
else
break;
_c++;
}
if (_t) {
if (strcmp(_t,_c)) {
if (!SwigPtrSort) {
qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);
for (i = 0; i < 256; i++) {
SwigStart[i] = SwigPtrN;
}
for (i = SwigPtrN-1; i >= 0; i--) {
SwigStart[(int) (SwigPtrTable[i].name[1])] = i;
}
for (i = 255; i >= 1; i--) {
if (SwigStart[i-1] > SwigStart[i])
SwigStart[i-1] = SwigStart[i];
}
SwigPtrSort = 1;
for (i = 0; i < SWIG_CACHESIZE; i++)
SwigCache[i].stat = 0;
}
/* First check cache for matches. Uses last cache value as starting point */
cache = &SwigCache[SwigLastCache];
for (i = 0; i < SWIG_CACHESIZE; i++) {
if (cache->stat) {
if (strcmp(_t,cache->name) == 0) {
if (strcmp(_c,cache->mapped) == 0) {
cache->stat++;
*ptr = (void *) _p;
if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr);
return (char *) 0;
}
}
}
SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
if (!SwigLastCache) cache = SwigCache;
else cache++;
}
/* We have a type mismatch. Will have to look through our type
mapping table to figure out whether or not we can accept this datatype */
start = SwigStart[(int) _t[1]];
end = SwigStart[(int) _t[1]+1];
sp = &SwigPtrTable[start];
while (start < end) {
if (swigcmp(_t,sp) == 0) break;
sp++;
start++;
}
if (start >= end) sp = 0;
/* Try to find a match for this */
if (sp) {
while (swigcmp(_t,sp) == 0) {
name = sp->name;
len = sp->len;
tp = sp->next;
/* Try to find entry for our given datatype */
while(tp) {
if (tp->len >= 255) {
return _c;
}
strcpy(temp_type,tp->name);
strncat(temp_type,_t+len,255-tp->len);
if (strcmp(_c,temp_type) == 0) {
strcpy(SwigCache[SwigCacheIndex].mapped,_c);
strcpy(SwigCache[SwigCacheIndex].name,_t);
SwigCache[SwigCacheIndex].stat = 1;
SwigCache[SwigCacheIndex].tp = tp;
SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
/* Get pointer value */
*ptr = (void *) _p;
if (tp->cast) *ptr = (*(tp->cast))(*ptr);
return (char *) 0;
}
tp = tp->next;
}
sp++;
/* Hmmm. Didn't find it this time */
}
}
/* Didn't find any sort of match for this data.
Get the pointer value and return the received type */
*ptr = (void *) _p;
return _c;
} else {
/* Found a match on the first try. Return pointer value */
*ptr = (void *) _p;
return (char *) 0;
}
} else {
/* No type specified. Good luck */
*ptr = (void *) _p;
return (char *) 0;
}
} else {
if (strcmp (_c, "NULL") == 0) {
*ptr = (void *) 0;
return (char *) 0;
}
*ptr = (void *) 0;
return _c;
}
}
/* Compatibility mode */
#define _swig_get_hex SWIG_GetPtr
#define SWIG_init initutilsc
@ -1232,6 +1736,11 @@ SWIGEXPORT(void,initutilsc)() {
SWIG_globals = SWIG_newvarlink();
m = Py_InitModule("utilsc", utilscMethods);
d = PyModule_GetDict(m);
wxClassInfo::CleanUpClasses();
wxClassInfo::InitializeClasses();
/*
* These are the pointer type-equivalency mappings.
* (Used by the SWIG pointer type-checker).

430
utils/wxPython/src/msw/windows.cpp
View File

@ -365,6 +365,58 @@ static PyObject *_wrap_wxWindow_Centre(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_CentreOnParent(_swigobj,_swigarg0) (_swigobj->CentreOnParent(_swigarg0))
static PyObject *_wrap_wxWindow_CentreOnParent(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _arg0;
int _arg1 = (wxHORIZONTAL);
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s|i:wxWindow_CentreOnParent",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_CentreOnParent. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_CentreOnParent(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxWindow_CenterOnParent(_swigobj,_swigarg0) (_swigobj->CenterOnParent(_swigarg0))
static PyObject *_wrap_wxWindow_CenterOnParent(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _arg0;
int _arg1 = (wxHORIZONTAL);
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s|i:wxWindow_CenterOnParent",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_CenterOnParent. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_CenterOnParent(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxWindow_ClientToScreenXY(_swigobj,_swigarg0,_swigarg1) (_swigobj->ClientToScreen(_swigarg0,_swigarg1))
static PyObject *_wrap_wxWindow_ClientToScreenXY(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -850,33 +902,6 @@ static PyObject *_wrap_wxWindow_GetConstraints(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_GetDefaultItem(_swigobj) (_swigobj->GetDefaultItem())
static PyObject *_wrap_wxWindow_GetDefaultItem(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxButton * _result;
wxWindow * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxWindow_GetDefaultItem",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_GetDefaultItem. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxButton *)wxWindow_GetDefaultItem(_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxButton_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
#define wxWindow_GetFont(_swigobj) (_swigobj->GetFont())
static PyObject *_wrap_wxWindow_GetFont(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -1014,6 +1039,44 @@ static PyObject *_wrap_wxWindow_GetLabel(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_SetLabel(_swigobj,_swigarg0) (_swigobj->SetLabel(_swigarg0))
static PyObject *_wrap_wxWindow_SetLabel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _arg0;
wxString * _arg1;
char * _argc0 = 0;
PyObject * _obj1 = 0;
self = self;
if(!PyArg_ParseTuple(args,"sO:wxWindow_SetLabel",&_argc0,&_obj1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_SetLabel. Expected _wxWindow_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;
wxWindow_SetLabel(_arg0,*_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
{
if (_obj1)
delete _arg1;
}
return _resultobj;
}
#define wxWindow_GetName(_swigobj) (_swigobj->GetName())
static PyObject *_wrap_wxWindow_GetName(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -1170,31 +1233,6 @@ static PyObject *_wrap_wxWindow_GetRect(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_GetReturnCode(_swigobj) (_swigobj->GetReturnCode())
static PyObject *_wrap_wxWindow_GetReturnCode(PyObject *self, PyObject *args) {
PyObject * _resultobj;
int _result;
wxWindow * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxWindow_GetReturnCode",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_GetReturnCode. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (int )wxWindow_GetReturnCode(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxWindow_GetScrollThumb(_swigobj,_swigarg0) (_swigobj->GetScrollThumb(_swigarg0))
static PyObject *_wrap_wxWindow_GetScrollThumb(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -1544,6 +1582,31 @@ static PyObject *_wrap_wxWindow_GetWindowStyleFlag(PyObject *self, PyObject *arg
return _resultobj;
}
#define wxWindow_Hide(_swigobj) (_swigobj->Hide())
static PyObject *_wrap_wxWindow_Hide(PyObject *self, PyObject *args) {
PyObject * _resultobj;
bool _result;
wxWindow * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxWindow_Hide",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_Hide. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxWindow_Hide(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxWindow_InitDialog(_swigobj) (_swigobj->InitDialog())
static PyObject *_wrap_wxWindow_InitDialog(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -1644,6 +1707,31 @@ static PyObject *_wrap_wxWindow_IsShown(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_IsTopLevel(_swigobj) (_swigobj->IsTopLevel())
static PyObject *_wrap_wxWindow_IsTopLevel(PyObject *self, PyObject *args) {
PyObject * _resultobj;
bool _result;
wxWindow * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxWindow_IsTopLevel",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_IsTopLevel. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxWindow_IsTopLevel(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxWindow_Layout(_swigobj) (_swigobj->Layout())
static PyObject *_wrap_wxWindow_Layout(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -1957,6 +2045,39 @@ static PyObject *_wrap_wxWindow_ReleaseMouse(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_Reparent(_swigobj,_swigarg0) (_swigobj->Reparent(_swigarg0))
static PyObject *_wrap_wxWindow_Reparent(PyObject *self, PyObject *args) {
PyObject * _resultobj;
bool _result;
wxWindow * _arg0;
wxWindow * _arg1;
char * _argc0 = 0;
char * _argc1 = 0;
self = self;
if(!PyArg_ParseTuple(args,"ss:wxWindow_Reparent",&_argc0,&_argc1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_Reparent. Expected _wxWindow_p.");
return NULL;
}
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxWindow_Reparent. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (bool )wxWindow_Reparent(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxWindow_ScreenToClientXY(_swigobj,_swigarg0,_swigarg1) (_swigobj->ScreenToClient(_swigarg0,_swigarg1))
static PyObject *_wrap_wxWindow_ScreenToClientXY(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -2203,34 +2324,6 @@ static PyObject *_wrap_wxWindow_SetConstraints(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_SetDoubleClick(_swigobj,_swigarg0) (_swigobj->SetDoubleClick(_swigarg0))
static PyObject *_wrap_wxWindow_SetDoubleClick(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _arg0;
bool _arg1;
char * _argc0 = 0;
int tempbool1;
self = self;
if(!PyArg_ParseTuple(args,"si:wxWindow_SetDoubleClick",&_argc0,&tempbool1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_SetDoubleClick. Expected _wxWindow_p.");
return NULL;
}
}
_arg1 = (bool ) tempbool1;
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_SetDoubleClick(_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 * _resultobj;
@ -2386,32 +2479,6 @@ static PyObject *_wrap_wxWindow_SetName(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxWindow_SetReturnCode(_swigobj,_swigarg0) (_swigobj->SetReturnCode(_swigarg0))
static PyObject *_wrap_wxWindow_SetReturnCode(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _arg0;
int _arg1;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"si:wxWindow_SetReturnCode",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxWindow_SetReturnCode. Expected _wxWindow_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxWindow_SetReturnCode(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxWindow_SetScrollbar(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (_swigobj->SetScrollbar(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
static PyObject *_wrap_wxWindow_SetScrollbar(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -3191,6 +3258,66 @@ static PyObject *_wrap_wxPanel_InitDialog(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxPanel_GetDefaultItem(_swigobj) (_swigobj->GetDefaultItem())
static PyObject *_wrap_wxPanel_GetDefaultItem(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxButton * _result;
wxPanel * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxPanel_GetDefaultItem",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPanel_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPanel_GetDefaultItem. Expected _wxPanel_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxButton *)wxPanel_GetDefaultItem(_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxButton_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
#define wxPanel_SetDefaultItem(_swigobj,_swigarg0) (_swigobj->SetDefaultItem(_swigarg0))
static PyObject *_wrap_wxPanel_SetDefaultItem(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxPanel * _arg0;
wxButton * _arg1;
char * _argc0 = 0;
char * _argc1 = 0;
self = self;
if(!PyArg_ParseTuple(args,"ss:wxPanel_SetDefaultItem",&_argc0,&_argc1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxPanel_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPanel_SetDefaultItem. Expected _wxPanel_p.");
return NULL;
}
}
if (_argc1) {
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxButton_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPanel_SetDefaultItem. Expected _wxButton_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxPanel_SetDefaultItem(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static void *SwigwxDialogTowxPanel(void *ptr) {
wxDialog *src;
wxPanel *dest;
@ -3553,6 +3680,65 @@ static PyObject *_wrap_wxDialog_ShowModal(PyObject *self, PyObject *args) {
return _resultobj;
}
#define wxDialog_GetReturnCode(_swigobj) (_swigobj->GetReturnCode())
static PyObject *_wrap_wxDialog_GetReturnCode(PyObject *self, PyObject *args) {
PyObject * _resultobj;
int _result;
wxDialog * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxDialog_GetReturnCode",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxDialog_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDialog_GetReturnCode. Expected _wxDialog_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (int )wxDialog_GetReturnCode(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxDialog_SetReturnCode(_swigobj,_swigarg0) (_swigobj->SetReturnCode(_swigarg0))
static PyObject *_wrap_wxDialog_SetReturnCode(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxDialog * _arg0;
int _arg1;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"si:wxDialog_SetReturnCode",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxDialog_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxDialog_SetReturnCode. Expected _wxDialog_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxDialog_SetReturnCode(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static void *SwigwxScrolledWindowTowxPanel(void *ptr) {
wxScrolledWindow *src;
wxPanel *dest;
src = (wxScrolledWindow *) ptr;
dest = (wxPanel *) src;
return (void *) dest;
}
static void *SwigwxScrolledWindowTowxWindow(void *ptr) {
wxScrolledWindow *src;
wxWindow *dest;
@ -5966,6 +6152,8 @@ static PyMethodDef windowscMethods[] = {
{ "wxScrolledWindow_GetScrollPixelsPerUnit", _wrap_wxScrolledWindow_GetScrollPixelsPerUnit, 1 },
{ "wxScrolledWindow_EnableScrolling", _wrap_wxScrolledWindow_EnableScrolling, 1 },
{ "new_wxScrolledWindow", _wrap_new_wxScrolledWindow, 1 },
{ "wxDialog_SetReturnCode", _wrap_wxDialog_SetReturnCode, 1 },
{ "wxDialog_GetReturnCode", _wrap_wxDialog_GetReturnCode, 1 },
{ "wxDialog_ShowModal", _wrap_wxDialog_ShowModal, 1 },
{ "wxDialog_Show", _wrap_wxDialog_Show, 1 },
{ "wxDialog_SetTitle", _wrap_wxDialog_SetTitle, 1 },
@ -5977,6 +6165,8 @@ static PyMethodDef windowscMethods[] = {
{ "wxDialog_EndModal", _wrap_wxDialog_EndModal, 1 },
{ "wxDialog_Centre", _wrap_wxDialog_Centre, 1 },
{ "new_wxDialog", _wrap_new_wxDialog, 1 },
{ "wxPanel_SetDefaultItem", _wrap_wxPanel_SetDefaultItem, 1 },
{ "wxPanel_GetDefaultItem", _wrap_wxPanel_GetDefaultItem, 1 },
{ "wxPanel_InitDialog", _wrap_wxPanel_InitDialog, 1 },
{ "new_wxPanel", _wrap_new_wxPanel, 1 },
{ "wxWindow_GetToolTip", _wrap_wxWindow_GetToolTip, 1 },
@ -6003,13 +6193,11 @@ static PyMethodDef windowscMethods[] = {
{ "wxWindow_SetDimensions", _wrap_wxWindow_SetDimensions, 1 },
{ "wxWindow_SetScrollPos", _wrap_wxWindow_SetScrollPos, 1 },
{ "wxWindow_SetScrollbar", _wrap_wxWindow_SetScrollbar, 1 },
{ "wxWindow_SetReturnCode", _wrap_wxWindow_SetReturnCode, 1 },
{ "wxWindow_SetName", _wrap_wxWindow_SetName, 1 },
{ "wxWindow_SetId", _wrap_wxWindow_SetId, 1 },
{ "wxWindow_SetForegroundColour", _wrap_wxWindow_SetForegroundColour, 1 },
{ "wxWindow_SetFont", _wrap_wxWindow_SetFont, 1 },
{ "wxWindow_SetFocus", _wrap_wxWindow_SetFocus, 1 },
{ "wxWindow_SetDoubleClick", _wrap_wxWindow_SetDoubleClick, 1 },
{ "wxWindow_SetConstraints", _wrap_wxWindow_SetConstraints, 1 },
{ "wxWindow_SetBackgroundColour", _wrap_wxWindow_SetBackgroundColour, 1 },
{ "wxWindow_SetAutoLayout", _wrap_wxWindow_SetAutoLayout, 1 },
@ -6017,6 +6205,7 @@ static PyMethodDef windowscMethods[] = {
{ "wxWindow_ScrollWindow", _wrap_wxWindow_ScrollWindow, 1 },
{ "wxWindow_ScreenToClient", _wrap_wxWindow_ScreenToClient, 1 },
{ "wxWindow_ScreenToClientXY", _wrap_wxWindow_ScreenToClientXY, 1 },
{ "wxWindow_Reparent", _wrap_wxWindow_Reparent, 1 },
{ "wxWindow_ReleaseMouse", _wrap_wxWindow_ReleaseMouse, 1 },
{ "wxWindow_Refresh", _wrap_wxWindow_Refresh, 1 },
{ "wxWindow_Raise", _wrap_wxWindow_Raise, 1 },
@ -6027,10 +6216,12 @@ static PyMethodDef windowscMethods[] = {
{ "wxWindow_Lower", _wrap_wxWindow_Lower, 1 },
{ "wxWindow_LoadFromResource", _wrap_wxWindow_LoadFromResource, 1 },
{ "wxWindow_Layout", _wrap_wxWindow_Layout, 1 },
{ "wxWindow_IsTopLevel", _wrap_wxWindow_IsTopLevel, 1 },
{ "wxWindow_IsShown", _wrap_wxWindow_IsShown, 1 },
{ "wxWindow_IsRetained", _wrap_wxWindow_IsRetained, 1 },
{ "wxWindow_IsEnabled", _wrap_wxWindow_IsEnabled, 1 },
{ "wxWindow_InitDialog", _wrap_wxWindow_InitDialog, 1 },
{ "wxWindow_Hide", _wrap_wxWindow_Hide, 1 },
{ "wxWindow_GetWindowStyleFlag", _wrap_wxWindow_GetWindowStyleFlag, 1 },
{ "wxWindow_GetTitle", _wrap_wxWindow_GetTitle, 1 },
{ "wxWindow_GetFullTextExtent", _wrap_wxWindow_GetFullTextExtent, 1 },
@ -6040,18 +6231,17 @@ static PyMethodDef windowscMethods[] = {
{ "wxWindow_GetScrollRange", _wrap_wxWindow_GetScrollRange, 1 },
{ "wxWindow_GetScrollPos", _wrap_wxWindow_GetScrollPos, 1 },
{ "wxWindow_GetScrollThumb", _wrap_wxWindow_GetScrollThumb, 1 },
{ "wxWindow_GetReturnCode", _wrap_wxWindow_GetReturnCode, 1 },
{ "wxWindow_GetRect", _wrap_wxWindow_GetRect, 1 },
{ "wxWindow_GetPosition", _wrap_wxWindow_GetPosition, 1 },
{ "wxWindow_GetPositionTuple", _wrap_wxWindow_GetPositionTuple, 1 },
{ "wxWindow_GetParent", _wrap_wxWindow_GetParent, 1 },
{ "wxWindow_GetName", _wrap_wxWindow_GetName, 1 },
{ "wxWindow_SetLabel", _wrap_wxWindow_SetLabel, 1 },
{ "wxWindow_GetLabel", _wrap_wxWindow_GetLabel, 1 },
{ "wxWindow_GetId", _wrap_wxWindow_GetId, 1 },
{ "wxWindow_GetGrandParent", _wrap_wxWindow_GetGrandParent, 1 },
{ "wxWindow_GetForegroundColour", _wrap_wxWindow_GetForegroundColour, 1 },
{ "wxWindow_GetFont", _wrap_wxWindow_GetFont, 1 },
{ "wxWindow_GetDefaultItem", _wrap_wxWindow_GetDefaultItem, 1 },
{ "wxWindow_GetConstraints", _wrap_wxWindow_GetConstraints, 1 },
{ "wxWindow_GetClientSize", _wrap_wxWindow_GetClientSize, 1 },
{ "wxWindow_GetClientSizeTuple", _wrap_wxWindow_GetClientSizeTuple, 1 },
@ -6068,6 +6258,8 @@ static PyMethodDef windowscMethods[] = {
{ "wxWindow_Close", _wrap_wxWindow_Close, 1 },
{ "wxWindow_ClientToScreen", _wrap_wxWindow_ClientToScreen, 1 },
{ "wxWindow_ClientToScreenXY", _wrap_wxWindow_ClientToScreenXY, 1 },
{ "wxWindow_CenterOnParent", _wrap_wxWindow_CenterOnParent, 1 },
{ "wxWindow_CentreOnParent", _wrap_wxWindow_CentreOnParent, 1 },
{ "wxWindow_Centre", _wrap_wxWindow_Centre, 1 },
{ "wxWindow_Center", _wrap_wxWindow_Center, 1 },
{ "wxWindow_CaptureMouse", _wrap_wxWindow_CaptureMouse, 1 },
@ -6093,6 +6285,13 @@ SWIGEXPORT(void,initwindowsc)() {
*/
SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMenuBar",SwigwxMenuBarTowxEvtHandler);
@ -6123,6 +6322,7 @@ SWIGEXPORT(void,initwindowsc)() {
SWIG_RegisterMapping("_wxImageList","_class_wxImageList",0);
SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -6130,6 +6330,8 @@ SWIGEXPORT(void,initwindowsc)() {
SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
SWIG_RegisterMapping("_wxPrinterDC","_class_wxPrinterDC",0);
SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
SWIG_RegisterMapping("_wxPanel","_class_wxScrolledWindow",SwigwxScrolledWindowTowxPanel);
SWIG_RegisterMapping("_wxPanel","_wxScrolledWindow",SwigwxScrolledWindowTowxPanel);
SWIG_RegisterMapping("_wxPanel","_class_wxDialog",SwigwxDialogTowxPanel);
SWIG_RegisterMapping("_wxPanel","_wxDialog",SwigwxDialogTowxPanel);
SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
@ -6138,6 +6340,7 @@ SWIGEXPORT(void,initwindowsc)() {
SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -6148,6 +6351,7 @@ SWIGEXPORT(void,initwindowsc)() {
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -6159,9 +6363,12 @@ SWIGEXPORT(void,initwindowsc)() {
SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
SWIG_RegisterMapping("_class_wxPanel","_class_wxScrolledWindow",SwigwxScrolledWindowTowxPanel);
SWIG_RegisterMapping("_class_wxPanel","_wxScrolledWindow",SwigwxScrolledWindowTowxPanel);
SWIG_RegisterMapping("_class_wxPanel","_class_wxDialog",SwigwxDialogTowxPanel);
SWIG_RegisterMapping("_class_wxPanel","_wxDialog",SwigwxDialogTowxPanel);
SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -6201,6 +6408,7 @@ SWIGEXPORT(void,initwindowsc)() {
SWIG_RegisterMapping("_class_wxMenu","_class_wxPyMenu",SwigwxPyMenuTowxMenu);
SWIG_RegisterMapping("_class_wxMenu","_wxPyMenu",SwigwxPyMenuTowxMenu);
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -6213,12 +6421,14 @@ SWIGEXPORT(void,initwindowsc)() {
SWIG_RegisterMapping("_short","_unsigned_short",0);
SWIG_RegisterMapping("_short","_signed_short",0);
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

67
utils/wxPython/src/msw/windows.py
View File

@ -6,11 +6,17 @@ from misc import *
from gdi import *
import wx
def wxDLG_PNT(win, point):
return win.ConvertDialogPointToPixels(point)
def wxDLG_PNT(win, point_or_x, y=None):
if y is None:
return win.ConvertDialogPointToPixels(point_or_x)
else:
return win.ConvertDialogPointToPixels(wxPoint(point_or_x, y))
def wxDLG_SZE(win, size):
return win.ConvertDialogSizeToPixels(size)
def wxDLG_SZE(win, size_width, height=None):
if height is None:
return win.ConvertDialogSizeToPixels(size_width)
else:
return win.ConvertDialogSizeToPixels(wxSize(size_width, height))
class wxEvtHandlerPtr :
def __init__(self,this):
@ -44,6 +50,12 @@ class wxWindowPtr(wxEvtHandlerPtr):
def Centre(self,*args):
val = apply(windowsc.wxWindow_Centre,(self.this,)+args)
return val
def CentreOnParent(self,*args):
val = apply(windowsc.wxWindow_CentreOnParent,(self.this,)+args)
return val
def CenterOnParent(self,*args):
val = apply(windowsc.wxWindow_CenterOnParent,(self.this,)+args)
return val
def ClientToScreenXY(self,arg0,arg1):
val = windowsc.wxWindow_ClientToScreenXY(self.this,arg0,arg1)
return val
@ -101,10 +113,6 @@ class wxWindowPtr(wxEvtHandlerPtr):
val = windowsc.wxWindow_GetConstraints(self.this)
val = wxLayoutConstraintsPtr(val)
return val
def GetDefaultItem(self):
val = windowsc.wxWindow_GetDefaultItem(self.this)
val = wxButtonPtr(val)
return val
def GetFont(self):
val = windowsc.wxWindow_GetFont(self.this)
val = wxFontPtr(val)
@ -124,6 +132,9 @@ class wxWindowPtr(wxEvtHandlerPtr):
def GetLabel(self):
val = windowsc.wxWindow_GetLabel(self.this)
return val
def SetLabel(self,arg0):
val = windowsc.wxWindow_SetLabel(self.this,arg0)
return val
def GetName(self):
val = windowsc.wxWindow_GetName(self.this)
return val
@ -144,9 +155,6 @@ class wxWindowPtr(wxEvtHandlerPtr):
val = wxRectPtr(val)
val.thisown = 1
return val
def GetReturnCode(self):
val = windowsc.wxWindow_GetReturnCode(self.this)
return val
def GetScrollThumb(self,arg0):
val = windowsc.wxWindow_GetScrollThumb(self.this,arg0)
return val
@ -180,6 +188,9 @@ class wxWindowPtr(wxEvtHandlerPtr):
def GetWindowStyleFlag(self):
val = windowsc.wxWindow_GetWindowStyleFlag(self.this)
return val
def Hide(self):
val = windowsc.wxWindow_Hide(self.this)
return val
def InitDialog(self):
val = windowsc.wxWindow_InitDialog(self.this)
return val
@ -192,6 +203,9 @@ class wxWindowPtr(wxEvtHandlerPtr):
def IsShown(self):
val = windowsc.wxWindow_IsShown(self.this)
return val
def IsTopLevel(self):
val = windowsc.wxWindow_IsTopLevel(self.this)
return val
def Layout(self):
val = windowsc.wxWindow_Layout(self.this)
return val
@ -226,6 +240,9 @@ class wxWindowPtr(wxEvtHandlerPtr):
def ReleaseMouse(self):
val = windowsc.wxWindow_ReleaseMouse(self.this)
return val
def Reparent(self,arg0):
val = windowsc.wxWindow_Reparent(self.this,arg0.this)
return val
def ScreenToClientXY(self,arg0,arg1):
val = windowsc.wxWindow_ScreenToClientXY(self.this,arg0,arg1)
return val
@ -253,9 +270,6 @@ class wxWindowPtr(wxEvtHandlerPtr):
def SetConstraints(self,arg0):
val = windowsc.wxWindow_SetConstraints(self.this,arg0.this)
return val
def SetDoubleClick(self,arg0):
val = windowsc.wxWindow_SetDoubleClick(self.this,arg0)
return val
def SetFocus(self):
val = windowsc.wxWindow_SetFocus(self.this)
return val
@ -271,9 +285,6 @@ class wxWindowPtr(wxEvtHandlerPtr):
def SetName(self,arg0):
val = windowsc.wxWindow_SetName(self.this,arg0)
return val
def SetReturnCode(self,arg0):
val = windowsc.wxWindow_SetReturnCode(self.this,arg0)
return val
def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
val = apply(windowsc.wxWindow_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
return val
@ -383,8 +394,22 @@ class wxPanelPtr(wxWindowPtr):
def InitDialog(self):
val = windowsc.wxPanel_InitDialog(self.this)
return val
def GetDefaultItem(self):
val = windowsc.wxPanel_GetDefaultItem(self.this)
val = wxButtonPtr(val)
return val
def SetDefaultItem(self,arg0):
val = windowsc.wxPanel_SetDefaultItem(self.this,arg0.this)
return val
def __repr__(self):
return "<C wxPanel instance>"
def GetDefaultItem(self):
import controls
val = windowsc.wxPanel_GetDefaultItem(self.this)
val = controls.wxButtonPtr(val)
return val
class wxPanel(wxPanelPtr):
def __init__(self,arg0,arg1,*args) :
argl = map(None,args)
@ -434,6 +459,12 @@ class wxDialogPtr(wxPanelPtr):
def ShowModal(self):
val = windowsc.wxDialog_ShowModal(self.this)
return val
def GetReturnCode(self):
val = windowsc.wxDialog_GetReturnCode(self.this)
return val
def SetReturnCode(self,arg0):
val = windowsc.wxDialog_SetReturnCode(self.this,arg0)
return val
def __repr__(self):
return "<C wxDialog instance>"
class wxDialog(wxDialogPtr):
@ -451,7 +482,7 @@ class wxDialog(wxDialogPtr):
class wxScrolledWindowPtr(wxWindowPtr):
class wxScrolledWindowPtr(wxPanelPtr):
def __init__(self,this):
self.this = this
self.thisown = 0

249
utils/wxPython/src/msw/windows2.cpp
View File

@ -2855,6 +2855,14 @@ static PyObject *_wrap_wxGridEvent_m_cell_get(PyObject *self, PyObject *args) {
return _resultobj;
}
static void *SwigwxNotebookEventTowxNotifyEvent(void *ptr) {
wxNotebookEvent *src;
wxNotifyEvent *dest;
src = (wxNotebookEvent *) ptr;
dest = (wxNotifyEvent *) src;
return (void *) dest;
}
static void *SwigwxNotebookEventTowxCommandEvent(void *ptr) {
wxNotebookEvent *src;
wxCommandEvent *dest;
@ -2921,6 +2929,58 @@ static PyObject *_wrap_wxNotebookEvent_GetOldSelection(PyObject *self, PyObject
return _resultobj;
}
#define wxNotebookEvent_SetOldSelection(_swigobj,_swigarg0) (_swigobj->SetOldSelection(_swigarg0))
static PyObject *_wrap_wxNotebookEvent_SetOldSelection(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxNotebookEvent * _arg0;
int _arg1;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"si:wxNotebookEvent_SetOldSelection",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxNotebookEvent_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotebookEvent_SetOldSelection. Expected _wxNotebookEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxNotebookEvent_SetOldSelection(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
#define wxNotebookEvent_SetSelection(_swigobj,_swigarg0) (_swigobj->SetSelection(_swigarg0))
static PyObject *_wrap_wxNotebookEvent_SetSelection(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxNotebookEvent * _arg0;
int _arg1;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"si:wxNotebookEvent_SetSelection",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxNotebookEvent_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxNotebookEvent_SetSelection. Expected _wxNotebookEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxNotebookEvent_SetSelection(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static void *SwigwxNotebookTowxControl(void *ptr) {
wxNotebook *src;
wxControl *dest;
@ -3482,7 +3542,7 @@ static PyObject *_wrap_wxNotebook_InsertPage(PyObject *self, PyObject *args) {
#define wxNotebook_GetPage(_swigobj,_swigarg0) (_swigobj->GetPage(_swigarg0))
static PyObject *_wrap_wxNotebook_GetPage(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxNotebookPage * _result;
wxWindow * _result;
wxNotebook * _arg0;
int _arg1;
char * _argc0 = 0;
@ -3499,17 +3559,17 @@ static PyObject *_wrap_wxNotebook_GetPage(PyObject *self, PyObject *args) {
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxNotebookPage *)wxNotebook_GetPage(_arg0,_arg1);
_result = (wxWindow *)wxNotebook_GetPage(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxNotebookPage_p");
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
static void wxNotebook_ResizeChildren(wxNotebook *self) {
wxSizeEvent evt(self->GetClientSize());
self->OnSize(evt);
self->GetEventHandler()->ProcessEvent(evt);
}
static PyObject *_wrap_wxNotebook_ResizeChildren(PyObject *self, PyObject *args) {
PyObject * _resultobj;
@ -3535,6 +3595,150 @@ static PyObject *_wrap_wxNotebook_ResizeChildren(PyObject *self, PyObject *args)
return _resultobj;
}
static void *SwigwxSplitterEventTowxCommandEvent(void *ptr) {
wxSplitterEvent *src;
wxCommandEvent *dest;
src = (wxSplitterEvent *) ptr;
dest = (wxCommandEvent *) src;
return (void *) dest;
}
static void *SwigwxSplitterEventTowxEvent(void *ptr) {
wxSplitterEvent *src;
wxEvent *dest;
src = (wxSplitterEvent *) ptr;
dest = (wxEvent *) src;
return (void *) dest;
}
#define wxSplitterEvent_GetSashPosition(_swigobj) (_swigobj->GetSashPosition())
static PyObject *_wrap_wxSplitterEvent_GetSashPosition(PyObject *self, PyObject *args) {
PyObject * _resultobj;
int _result;
wxSplitterEvent * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxSplitterEvent_GetSashPosition",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSplitterEvent_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSplitterEvent_GetSashPosition. Expected _wxSplitterEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (int )wxSplitterEvent_GetSashPosition(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxSplitterEvent_GetX(_swigobj) (_swigobj->GetX())
static PyObject *_wrap_wxSplitterEvent_GetX(PyObject *self, PyObject *args) {
PyObject * _resultobj;
int _result;
wxSplitterEvent * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxSplitterEvent_GetX",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSplitterEvent_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSplitterEvent_GetX. Expected _wxSplitterEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (int )wxSplitterEvent_GetX(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxSplitterEvent_GetY(_swigobj) (_swigobj->GetY())
static PyObject *_wrap_wxSplitterEvent_GetY(PyObject *self, PyObject *args) {
PyObject * _resultobj;
int _result;
wxSplitterEvent * _arg0;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"s:wxSplitterEvent_GetY",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSplitterEvent_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSplitterEvent_GetY. Expected _wxSplitterEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (int )wxSplitterEvent_GetY(_arg0);
wxPy_END_ALLOW_THREADS;
} _resultobj = Py_BuildValue("i",_result);
return _resultobj;
}
#define wxSplitterEvent_GetWindowBeingRemoved(_swigobj) (_swigobj->GetWindowBeingRemoved())
static PyObject *_wrap_wxSplitterEvent_GetWindowBeingRemoved(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxWindow * _result;
wxSplitterEvent * _arg0;
char * _argc0 = 0;
char _ptemp[128];
self = self;
if(!PyArg_ParseTuple(args,"s:wxSplitterEvent_GetWindowBeingRemoved",&_argc0))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSplitterEvent_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSplitterEvent_GetWindowBeingRemoved. Expected _wxSplitterEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
_result = (wxWindow *)wxSplitterEvent_GetWindowBeingRemoved(_arg0);
wxPy_END_ALLOW_THREADS;
} SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
_resultobj = Py_BuildValue("s",_ptemp);
return _resultobj;
}
#define wxSplitterEvent_SetSashPosition(_swigobj,_swigarg0) (_swigobj->SetSashPosition(_swigarg0))
static PyObject *_wrap_wxSplitterEvent_SetSashPosition(PyObject *self, PyObject *args) {
PyObject * _resultobj;
wxSplitterEvent * _arg0;
int _arg1;
char * _argc0 = 0;
self = self;
if(!PyArg_ParseTuple(args,"si:wxSplitterEvent_SetSashPosition",&_argc0,&_arg1))
return NULL;
if (_argc0) {
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxSplitterEvent_p")) {
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxSplitterEvent_SetSashPosition. Expected _wxSplitterEvent_p.");
return NULL;
}
}
{
wxPy_BEGIN_ALLOW_THREADS;
wxSplitterEvent_SetSashPosition(_arg0,_arg1);
wxPy_END_ALLOW_THREADS;
} Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;
}
static void *SwigwxSplitterWindowTowxWindow(void *ptr) {
wxSplitterWindow *src;
wxWindow *dest;
@ -4250,6 +4454,11 @@ static PyMethodDef windows2cMethods[] = {
{ "wxSplitterWindow_GetMinimumPaneSize", _wrap_wxSplitterWindow_GetMinimumPaneSize, 1 },
{ "wxSplitterWindow_GetBorderSize", _wrap_wxSplitterWindow_GetBorderSize, 1 },
{ "new_wxSplitterWindow", _wrap_new_wxSplitterWindow, 1 },
{ "wxSplitterEvent_SetSashPosition", _wrap_wxSplitterEvent_SetSashPosition, 1 },
{ "wxSplitterEvent_GetWindowBeingRemoved", _wrap_wxSplitterEvent_GetWindowBeingRemoved, 1 },
{ "wxSplitterEvent_GetY", _wrap_wxSplitterEvent_GetY, 1 },
{ "wxSplitterEvent_GetX", _wrap_wxSplitterEvent_GetX, 1 },
{ "wxSplitterEvent_GetSashPosition", _wrap_wxSplitterEvent_GetSashPosition, 1 },
{ "wxNotebook_ResizeChildren", _wrap_wxNotebook_ResizeChildren, 1 },
{ "wxNotebook_GetPage", _wrap_wxNotebook_GetPage, 1 },
{ "wxNotebook_InsertPage", _wrap_wxNotebook_InsertPage, 1 },
@ -4269,6 +4478,8 @@ static PyMethodDef windows2cMethods[] = {
{ "wxNotebook_SetSelection", _wrap_wxNotebook_SetSelection, 1 },
{ "wxNotebook_GetPageCount", _wrap_wxNotebook_GetPageCount, 1 },
{ "new_wxNotebook", _wrap_new_wxNotebook, 1 },
{ "wxNotebookEvent_SetSelection", _wrap_wxNotebookEvent_SetSelection, 1 },
{ "wxNotebookEvent_SetOldSelection", _wrap_wxNotebookEvent_SetOldSelection, 1 },
{ "wxNotebookEvent_GetOldSelection", _wrap_wxNotebookEvent_GetOldSelection, 1 },
{ "wxNotebookEvent_GetSelection", _wrap_wxNotebookEvent_GetSelection, 1 },
{ "wxGridEvent_m_cell_get", _wrap_wxGridEvent_m_cell_get, 1 },
@ -4400,6 +4611,8 @@ SWIGEXPORT(void,initwindows2c)() {
* (Used by the SWIG pointer type-checker).
*/
SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
SWIG_RegisterMapping("_wxEvent","_class_wxSplitterEvent",SwigwxSplitterEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_wxSplitterEvent",SwigwxSplitterEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_wxNotebookEvent",SwigwxNotebookEventTowxEvent);
SWIG_RegisterMapping("_wxEvent","_class_wxGridEvent",SwigwxGridEventTowxEvent);
@ -4408,6 +4621,13 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxTaskBarIcon",SwigwxTaskBarIconTowxEvtHandler);
@ -4422,6 +4642,9 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxNotifyEvent);
SWIG_RegisterMapping("_wxNotifyEvent","_wxNotebookEvent",SwigwxNotebookEventTowxNotifyEvent);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxGrid","_class_wxGrid",0);
@ -4443,6 +4666,7 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -4470,18 +4694,24 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_class_wxNotebookEvent","_wxNotebookEvent",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
SWIG_RegisterMapping("_uint","_wxWindowID",0);
SWIG_RegisterMapping("_class_wxEvent","_class_wxSplitterEvent",SwigwxSplitterEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxSplitterEvent",SwigwxSplitterEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxNotebookEvent",SwigwxNotebookEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_class_wxGridEvent",SwigwxGridEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxGridEvent",SwigwxGridEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
SWIG_RegisterMapping("_wxSplitterEvent","_class_wxSplitterEvent",0);
SWIG_RegisterMapping("_wxGridEvent","_class_wxGridEvent",0);
SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxSplitterEvent",SwigwxSplitterEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_wxSplitterEvent",SwigwxSplitterEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_wxNotebookEvent",SwigwxNotebookEventTowxCommandEvent);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
@ -4496,10 +4726,14 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxNotifyEvent);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotebookEvent",SwigwxNotebookEventTowxNotifyEvent);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -4508,6 +4742,7 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
SWIG_RegisterMapping("_class_wxSplitterEvent","_wxSplitterEvent",0);
SWIG_RegisterMapping("_wxNotebook","_class_wxNotebook",0);
SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
SWIG_RegisterMapping("_unsigned_long","_long",0);
@ -4524,6 +4759,7 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -4576,6 +4812,7 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_wxControl","_wxNotebook",SwigwxNotebookTowxControl);
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -4595,12 +4832,14 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_class_wxImageList","_wxImageList",0);
SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
SWIG_RegisterMapping("_class_wxNotebook","_wxNotebook",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);
@ -4638,6 +4877,8 @@ SWIGEXPORT(void,initwindows2c)() {
SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0);
SWIG_RegisterMapping("_class_wxGridEvent","_wxGridEvent",0);
SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxSplitterEvent",SwigwxSplitterEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_wxSplitterEvent",SwigwxSplitterEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_class_wxNotebookEvent",SwigwxNotebookEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_wxNotebookEvent",SwigwxNotebookEventTowxCommandEvent);
SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0);

38
utils/wxPython/src/msw/windows2.py
View File

@ -361,7 +361,7 @@ class wxGridEvent(wxGridEventPtr):
class wxNotebookEventPtr(wxCommandEventPtr):
class wxNotebookEventPtr(wxNotifyEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
@ -371,6 +371,12 @@ class wxNotebookEventPtr(wxCommandEventPtr):
def GetOldSelection(self):
val = windows2c.wxNotebookEvent_GetOldSelection(self.this)
return val
def SetOldSelection(self,arg0):
val = windows2c.wxNotebookEvent_SetOldSelection(self.this,arg0)
return val
def SetSelection(self,arg0):
val = windows2c.wxNotebookEvent_SetSelection(self.this,arg0)
return val
def __repr__(self):
return "<C wxNotebookEvent instance>"
class wxNotebookEvent(wxNotebookEventPtr):
@ -435,6 +441,7 @@ class wxNotebookPtr(wxControlPtr):
return val
def GetPage(self,arg0):
val = windows2c.wxNotebook_GetPage(self.this,arg0)
val = wxWindowPtr(val)
return val
def ResizeChildren(self):
val = windows2c.wxNotebook_ResizeChildren(self.this)
@ -456,6 +463,35 @@ class wxNotebook(wxNotebookPtr):
class wxSplitterEventPtr(wxCommandEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def GetSashPosition(self):
val = windows2c.wxSplitterEvent_GetSashPosition(self.this)
return val
def GetX(self):
val = windows2c.wxSplitterEvent_GetX(self.this)
return val
def GetY(self):
val = windows2c.wxSplitterEvent_GetY(self.this)
return val
def GetWindowBeingRemoved(self):
val = windows2c.wxSplitterEvent_GetWindowBeingRemoved(self.this)
val = wxWindowPtr(val)
return val
def SetSashPosition(self,arg0):
val = windows2c.wxSplitterEvent_SetSashPosition(self.this,arg0)
return val
def __repr__(self):
return "<C wxSplitterEvent instance>"
class wxSplitterEvent(wxSplitterEventPtr):
def __init__(self,this):
self.this = this
class wxSplitterWindowPtr(wxWindowPtr):
def __init__(self,this):
self.this = this

18
utils/wxPython/src/msw/windows3.cpp
View File

@ -1654,6 +1654,13 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
SWIG_RegisterMapping("_signed_long","_long",0);
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxSashLayoutWindow",SwigwxSashLayoutWindowTowxEvtHandler);
@ -1664,6 +1671,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxGrid","_class_wxGrid",0);
@ -1690,6 +1698,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_wxSashLayoutWindow","_class_wxSashLayoutWindow",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -1722,6 +1731,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_class_wxSashWindow","_wxSashLayoutWindow",SwigwxSashLayoutWindowTowxSashWindow);
SWIG_RegisterMapping("_class_wxSashWindow","_wxSashWindow",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
@ -1734,6 +1744,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_class_wxEvent","_wxSashEvent",SwigwxSashEventTowxEvent);
SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
SWIG_RegisterMapping("_wxSplitterEvent","_class_wxSplitterEvent",0);
SWIG_RegisterMapping("_wxGridEvent","_class_wxGridEvent",0);
SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxSashEvent",SwigwxSashEventTowxCommandEvent);
@ -1752,6 +1763,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
@ -1759,6 +1771,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_wxCalculateLayoutEvent","_class_wxCalculateLayoutEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
@ -1767,6 +1780,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
SWIG_RegisterMapping("_class_wxSplitterEvent","_wxSplitterEvent",0);
SWIG_RegisterMapping("_wxNotebook","_class_wxNotebook",0);
SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
SWIG_RegisterMapping("_unsigned_long","_long",0);
@ -1782,6 +1796,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -1835,6 +1850,7 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -1858,12 +1874,14 @@ SWIGEXPORT(void,initwindows3c)() {
SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
SWIG_RegisterMapping("_class_wxNotebook","_wxNotebook",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);

70
utils/wxPython/src/msw/wx.cpp
View File

@ -33,8 +33,9 @@
* and things like that.
*
* $Log$
* Revision 1.10 1999/05/02 02:06:37 RD
* More for wxPython 2.0b9 (hopefully the last...)
* Revision 1.11 1999/06/22 07:03:29 RD
* wxPython 2.1b1 for wxMSW (wxGTK coming soon)
* Lots of changes, see the README.txt for details...
*
************************************************************************/
@ -621,6 +622,7 @@ extern "C" SWIGEXPORT(void,initwindowsc)();
extern "C" SWIGEXPORT(void,initwindows2c)();
extern "C" SWIGEXPORT(void,initeventsc)();
extern "C" SWIGEXPORT(void,initmiscc)();
extern "C" SWIGEXPORT(void,initmisc2c)();
extern "C" SWIGEXPORT(void,initgdic)();
extern "C" SWIGEXPORT(void,initmdic)();
extern "C" SWIGEXPORT(void,initcontrolsc)();
@ -630,6 +632,7 @@ extern "C" SWIGEXPORT(void,initstattoolc)();
extern "C" SWIGEXPORT(void,initframesc)();
extern "C" SWIGEXPORT(void,initwindows3c)();
extern "C" SWIGEXPORT(void,initimagec)();
extern "C" SWIGEXPORT(void,initprintfwc)();
#ifndef SEPARATE
extern "C" SWIGEXPORT(void,initutilsc)();
extern "C" SWIGEXPORT(void,initglcanvasc)();
@ -1366,6 +1369,7 @@ SWIGEXPORT(void,initwxc)() {
PyDict_SetItemString(d,"wxDEFAULT_FRAME_STYLE", PyInt_FromLong((long) wxDEFAULT_FRAME_STYLE));
PyDict_SetItemString(d,"wxDEFAULT_DIALOG_STYLE", PyInt_FromLong((long) wxDEFAULT_DIALOG_STYLE));
PyDict_SetItemString(d,"wxFRAME_TOOL_WINDOW", PyInt_FromLong((long) wxFRAME_TOOL_WINDOW));
PyDict_SetItemString(d,"wxFRAME_FLOAT_ON_PARENT", PyInt_FromLong((long) wxFRAME_FLOAT_ON_PARENT));
PyDict_SetItemString(d,"wxCLIP_CHILDREN", PyInt_FromLong((long) wxCLIP_CHILDREN));
PyDict_SetItemString(d,"wxRETAINED", PyInt_FromLong((long) wxRETAINED));
PyDict_SetItemString(d,"wxBACKINGSTORE", PyInt_FromLong((long) wxBACKINGSTORE));
@ -1405,6 +1409,7 @@ SWIGEXPORT(void,initwxc)() {
PyDict_SetItemString(d,"wxGA_PROGRESSBAR", PyInt_FromLong((long) wxGA_PROGRESSBAR));
PyDict_SetItemString(d,"wxGA_HORIZONTAL", PyInt_FromLong((long) wxGA_HORIZONTAL));
PyDict_SetItemString(d,"wxGA_VERTICAL", PyInt_FromLong((long) wxGA_VERTICAL));
PyDict_SetItemString(d,"wxGA_SMOOTH", PyInt_FromLong((long) wxGA_SMOOTH));
PyDict_SetItemString(d,"wxSL_HORIZONTAL", PyInt_FromLong((long) wxSL_HORIZONTAL));
PyDict_SetItemString(d,"wxSL_VERTICAL", PyInt_FromLong((long) wxSL_VERTICAL));
PyDict_SetItemString(d,"wxSL_AUTOTICKS", PyInt_FromLong((long) wxSL_AUTOTICKS));
@ -1482,6 +1487,10 @@ SWIGEXPORT(void,initwxc)() {
PyDict_SetItemString(d,"wxDF_FILENAME", PyInt_FromLong((long) wxDF_FILENAME));
PyDict_SetItemString(d,"wxPORTRAIT", PyInt_FromLong((long) wxPORTRAIT));
PyDict_SetItemString(d,"wxLANDSCAPE", PyInt_FromLong((long) wxLANDSCAPE));
PyDict_SetItemString(d,"wxPRINT_QUALITY_HIGH", PyInt_FromLong((long) wxPRINT_QUALITY_HIGH));
PyDict_SetItemString(d,"wxPRINT_QUALITY_MEDIUM", PyInt_FromLong((long) wxPRINT_QUALITY_MEDIUM));
PyDict_SetItemString(d,"wxPRINT_QUALITY_LOW", PyInt_FromLong((long) wxPRINT_QUALITY_LOW));
PyDict_SetItemString(d,"wxPRINT_QUALITY_DRAFT", PyInt_FromLong((long) wxPRINT_QUALITY_DRAFT));
PyDict_SetItemString(d,"wxID_OPEN", PyInt_FromLong((long) wxID_OPEN));
PyDict_SetItemString(d,"wxID_CLOSE", PyInt_FromLong((long) wxID_CLOSE));
PyDict_SetItemString(d,"wxID_NEW", PyInt_FromLong((long) wxID_NEW));
@ -1546,6 +1555,10 @@ SWIGEXPORT(void,initwxc)() {
PyDict_SetItemString(d,"wxACCEL_ALT", PyInt_FromLong((long) wxACCEL_ALT));
PyDict_SetItemString(d,"wxACCEL_CTRL", PyInt_FromLong((long) wxACCEL_CTRL));
PyDict_SetItemString(d,"wxACCEL_SHIFT", PyInt_FromLong((long) wxACCEL_SHIFT));
PyDict_SetItemString(d,"wxPD_AUTO_HIDE", PyInt_FromLong((long) wxPD_AUTO_HIDE));
PyDict_SetItemString(d,"wxPD_APP_MODAL", PyInt_FromLong((long) wxPD_APP_MODAL));
PyDict_SetItemString(d,"wxPD_CAN_ABORT", PyInt_FromLong((long) wxPD_CAN_ABORT));
PyDict_SetItemString(d,"wxNO_DEFAULT", PyInt_FromLong((long) wxNO_DEFAULT));
PyDict_SetItemString(d,"wxDEFAULT", PyInt_FromLong((long) wxDEFAULT));
PyDict_SetItemString(d,"wxDECORATIVE", PyInt_FromLong((long) wxDECORATIVE));
PyDict_SetItemString(d,"wxROMAN", PyInt_FromLong((long) wxROMAN));
@ -1766,6 +1779,9 @@ SWIGEXPORT(void,initwxc)() {
PyDict_SetItemString(d,"wxPAPER_A2", PyInt_FromLong((long) wxPAPER_A2));
PyDict_SetItemString(d,"wxPAPER_A3_TRANSVERSE", PyInt_FromLong((long) wxPAPER_A3_TRANSVERSE));
PyDict_SetItemString(d,"wxPAPER_A3_EXTRA_TRANSVERSE", PyInt_FromLong((long) wxPAPER_A3_EXTRA_TRANSVERSE));
PyDict_SetItemString(d,"wxDUPLEX_SIMPLEX", PyInt_FromLong((long) wxDUPLEX_SIMPLEX));
PyDict_SetItemString(d,"wxDUPLEX_HORIZONTAL", PyInt_FromLong((long) wxDUPLEX_HORIZONTAL));
PyDict_SetItemString(d,"wxDUPLEX_VERTICAL", PyInt_FromLong((long) wxDUPLEX_VERTICAL));
PyDict_SetItemString(d,"FALSE", PyInt_FromLong((long) 0));
PyDict_SetItemString(d,"false", PyInt_FromLong((long) 0));
PyDict_SetItemString(d,"TRUE", PyInt_FromLong((long) 1));
@ -1825,6 +1841,13 @@ SWIGEXPORT(void,initwxc)() {
PyDict_SetItemString(d,"wxEVT_SCROLL_PAGEUP", PyInt_FromLong((long) wxEVT_SCROLL_PAGEUP));
PyDict_SetItemString(d,"wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong((long) wxEVT_SCROLL_PAGEDOWN));
PyDict_SetItemString(d,"wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong((long) wxEVT_SCROLL_THUMBTRACK));
PyDict_SetItemString(d,"wxEVT_SCROLLWIN_TOP", PyInt_FromLong((long) wxEVT_SCROLLWIN_TOP));
PyDict_SetItemString(d,"wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong((long) wxEVT_SCROLLWIN_BOTTOM));
PyDict_SetItemString(d,"wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong((long) wxEVT_SCROLLWIN_LINEUP));
PyDict_SetItemString(d,"wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong((long) wxEVT_SCROLLWIN_LINEDOWN));
PyDict_SetItemString(d,"wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong((long) wxEVT_SCROLLWIN_PAGEUP));
PyDict_SetItemString(d,"wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong((long) wxEVT_SCROLLWIN_PAGEDOWN));
PyDict_SetItemString(d,"wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong((long) wxEVT_SCROLLWIN_THUMBTRACK));
PyDict_SetItemString(d,"wxEVT_SIZE", PyInt_FromLong((long) wxEVT_SIZE));
PyDict_SetItemString(d,"wxEVT_MOVE", PyInt_FromLong((long) wxEVT_MOVE));
PyDict_SetItemString(d,"wxEVT_CLOSE_WINDOW", PyInt_FromLong((long) wxEVT_CLOSE_WINDOW));
@ -1899,11 +1922,16 @@ SWIGEXPORT(void,initwxc)() {
PyDict_SetItemString(d,"wxEVT_COMMAND_LIST_KEY_DOWN", PyInt_FromLong((long) wxEVT_COMMAND_LIST_KEY_DOWN));
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_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_NOTEBOOK_PAGE_CHANGING", PyInt_FromLong((long) wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING));
PyDict_SetItemString(d,"__version__", PyString_FromString("2.0b9"));
PyDict_SetItemString(d,"wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING", PyInt_FromLong((long) wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING));
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.1b1"));
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);
@ -1920,6 +1948,7 @@ SWIGEXPORT(void,initwxc)() {
initwindows2c();
initeventsc();
initmiscc();
initmisc2c();
initgdic();
initmdic();
initcontrolsc();
@ -1929,6 +1958,7 @@ SWIGEXPORT(void,initwxc)() {
initframesc();
initwindows3c();
initimagec();
initprintfwc();
#ifndef SEPARATE
initutilsc();
#ifdef WITH_GLCANVAS
@ -1947,6 +1977,13 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_class_wxJPEGHandler","_wxJPEGHandler",0);
SWIG_RegisterMapping("_wxBMPHandler","_class_wxBMPHandler",0);
SWIG_RegisterMapping("_wxImage","_class_wxImage",0);
SWIG_RegisterMapping("_wxPrintQuality","_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_signed_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_unsigned_int",0);
SWIG_RegisterMapping("_wxPrintQuality","_wxWindowID",0);
SWIG_RegisterMapping("_wxPrintQuality","_uint",0);
SWIG_RegisterMapping("_wxPrintQuality","_EBool",0);
SWIG_RegisterMapping("_wxPrintQuality","_size_t",0);
SWIG_RegisterMapping("_wxFontData","_class_wxFontData",0);
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
@ -1958,15 +1995,17 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxGIFHandler","_class_wxGIFHandler",0);
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
SWIG_RegisterMapping("_wxNotifyEvent","_class_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxImageHandler","_class_wxImageHandler",0);
SWIG_RegisterMapping("_class_wxTreeCtrl","_wxTreeCtrl",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
SWIG_RegisterMapping("_wxToolTip","_class_wxToolTip",0);
SWIG_RegisterMapping("_wxGrid","_class_wxGrid",0);
SWIG_RegisterMapping("_wxPNGHandler","_class_wxPNGHandler",0);
SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
SWIG_RegisterMapping("_class_wxColourData","_wxColourData",0);
SWIG_RegisterMapping("_class_wxPageSetupDialogData","_wxPageSetupDialogData",0);
SWIG_RegisterMapping("_wxPrinter","_class_wxPrinter",0);
SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
SWIG_RegisterMapping("_byte","_unsigned_char",0);
@ -1974,6 +2013,7 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
SWIG_RegisterMapping("_wxNotebookEvent","_class_wxNotebookEvent",0);
SWIG_RegisterMapping("_wxPyPrintout","_class_wxPyPrintout",0);
SWIG_RegisterMapping("_long","_wxDash",0);
SWIG_RegisterMapping("_long","_unsigned_long",0);
SWIG_RegisterMapping("_long","_signed_long",0);
@ -1988,9 +2028,12 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
SWIG_RegisterMapping("_wxListEvent","_class_wxListEvent",0);
SWIG_RegisterMapping("_class_wxSingleChoiceDialog","_wxSingleChoiceDialog",0);
SWIG_RegisterMapping("_wxProgressDialog","_class_wxProgressDialog",0);
SWIG_RegisterMapping("_class_wxBMPHandler","_wxBMPHandler",0);
SWIG_RegisterMapping("_wxPrintPreview","_class_wxPrintPreview",0);
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
SWIG_RegisterMapping("_wxSashLayoutWindow","_class_wxSashLayoutWindow",0);
SWIG_RegisterMapping("_size_t","_wxPrintQuality",0);
SWIG_RegisterMapping("_size_t","_unsigned_int",0);
SWIG_RegisterMapping("_size_t","_int",0);
SWIG_RegisterMapping("_size_t","_wxWindowID",0);
@ -2007,14 +2050,15 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0);
SWIG_RegisterMapping("_wxPyEvent","_class_wxPyEvent",0);
SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0);
SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0);
SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
SWIG_RegisterMapping("_class_wxToolTip","_wxToolTip",0);
SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0);
SWIG_RegisterMapping("_class_wxGrid","_wxGrid",0);
SWIG_RegisterMapping("_class_wxPNGHandler","_wxPNGHandler",0);
SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
SWIG_RegisterMapping("_wxPageSetupDialog","_class_wxPageSetupDialog",0);
SWIG_RegisterMapping("_class_wxPrinter","_wxPrinter",0);
SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
@ -2022,14 +2066,17 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
SWIG_RegisterMapping("_class_wxNotebookEvent","_wxNotebookEvent",0);
SWIG_RegisterMapping("_class_wxPyPrintout","_wxPyPrintout",0);
SWIG_RegisterMapping("_class_wxSashWindow","_wxSashWindow",0);
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
SWIG_RegisterMapping("_uint","_wxPrintQuality",0);
SWIG_RegisterMapping("_uint","_size_t",0);
SWIG_RegisterMapping("_uint","_unsigned_int",0);
SWIG_RegisterMapping("_uint","_int",0);
SWIG_RegisterMapping("_uint","_wxWindowID",0);
SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
SWIG_RegisterMapping("_wxSplitterEvent","_class_wxSplitterEvent",0);
SWIG_RegisterMapping("_wxGridEvent","_class_wxGridEvent",0);
SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
@ -2049,7 +2096,9 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
SWIG_RegisterMapping("_wxColourDialog","_class_wxColourDialog",0);
SWIG_RegisterMapping("_wxPrintData","_class_wxPrintData",0);
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
SWIG_RegisterMapping("_class_wxNotifyEvent","_wxNotifyEvent",0);
SWIG_RegisterMapping("_wxMessageDialog","_class_wxMessageDialog",0);
SWIG_RegisterMapping("_class_wxPyEvent","_wxPyEvent",0);
SWIG_RegisterMapping("_wxTextEntryDialog","_class_wxTextEntryDialog",0);
@ -2060,19 +2109,23 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
SWIG_RegisterMapping("_wxCalculateLayoutEvent","_class_wxCalculateLayoutEvent",0);
SWIG_RegisterMapping("_EBool","_wxPrintQuality",0);
SWIG_RegisterMapping("_EBool","_signed_int",0);
SWIG_RegisterMapping("_EBool","_int",0);
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0);
SWIG_RegisterMapping("_class_wxPreviewFrame","_wxPreviewFrame",0);
SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
SWIG_RegisterMapping("_class_wxSplitterEvent","_wxSplitterEvent",0);
SWIG_RegisterMapping("_wxNotebook","_class_wxNotebook",0);
SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
SWIG_RegisterMapping("_unsigned_long","_long",0);
SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
SWIG_RegisterMapping("_class_wxProgressDialog","_wxProgressDialog",0);
SWIG_RegisterMapping("_wxPyApp","_class_wxPyApp",0);
SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0);
SWIG_RegisterMapping("_class_wxTreeEvent","_wxTreeEvent",0);
@ -2087,6 +2140,7 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
SWIG_RegisterMapping("_class_wxMessageDialog","_wxMessageDialog",0);
SWIG_RegisterMapping("_signed_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_signed_int","_EBool",0);
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
SWIG_RegisterMapping("_signed_int","_int",0);
@ -2143,6 +2197,7 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
SWIG_RegisterMapping("_unsigned_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_unsigned_int","_size_t",0);
SWIG_RegisterMapping("_unsigned_int","_uint",0);
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
@ -2169,12 +2224,14 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
SWIG_RegisterMapping("_class_wxNotebook","_wxNotebook",0);
SWIG_RegisterMapping("_wxJPEGHandler","_class_wxJPEGHandler",0);
SWIG_RegisterMapping("_wxWindowID","_wxPrintQuality",0);
SWIG_RegisterMapping("_wxWindowID","_size_t",0);
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
SWIG_RegisterMapping("_wxWindowID","_uint",0);
SWIG_RegisterMapping("_wxWindowID","_int",0);
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
SWIG_RegisterMapping("_int","_wxPrintQuality",0);
SWIG_RegisterMapping("_int","_size_t",0);
SWIG_RegisterMapping("_int","_EBool",0);
SWIG_RegisterMapping("_int","_uint",0);
@ -2183,6 +2240,7 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_int","_signed_int",0);
SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0);
SWIG_RegisterMapping("_class_wxListEvent","_wxListEvent",0);
SWIG_RegisterMapping("_class_wxPrintPreview","_wxPrintPreview",0);
SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0);
SWIG_RegisterMapping("_wxButton","_class_wxButton",0);
SWIG_RegisterMapping("_class_wxPyApp","_wxPyApp",0);
@ -2214,6 +2272,7 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxFontDialog","_class_wxFontDialog",0);
SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
SWIG_RegisterMapping("_class_wxSplitterWindow","_wxSplitterWindow",0);
SWIG_RegisterMapping("_wxPreviewFrame","_class_wxPreviewFrame",0);
SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
@ -2236,6 +2295,7 @@ SWIGEXPORT(void,initwxc)() {
SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0);
SWIG_RegisterMapping("_class_wxColourDialog","_wxColourDialog",0);
SWIG_RegisterMapping("_class_wxPrintData","_wxPrintData",0);
SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
SWIG_RegisterMapping("_wxDash","_long",0);
SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);

136
utils/wxPython/src/msw/wx.py
View File

@ -3,6 +3,8 @@ import wxc
from misc import *
from misc2 import *
from windows import *
from gdi import *
@ -26,6 +28,8 @@ from cmndlgs import *
from windows3 import *
from image import *
from printfw import *
class wxPyAppPtr(wxEvtHandlerPtr):
def __init__(self,this):
self.this = this
@ -152,6 +156,7 @@ wxDIALOG_MODELESS = wxc.wxDIALOG_MODELESS
wxDEFAULT_FRAME_STYLE = wxc.wxDEFAULT_FRAME_STYLE
wxDEFAULT_DIALOG_STYLE = wxc.wxDEFAULT_DIALOG_STYLE
wxFRAME_TOOL_WINDOW = wxc.wxFRAME_TOOL_WINDOW
wxFRAME_FLOAT_ON_PARENT = wxc.wxFRAME_FLOAT_ON_PARENT
wxCLIP_CHILDREN = wxc.wxCLIP_CHILDREN
wxRETAINED = wxc.wxRETAINED
wxBACKINGSTORE = wxc.wxBACKINGSTORE
@ -191,6 +196,7 @@ wxRB_GROUP = wxc.wxRB_GROUP
wxGA_PROGRESSBAR = wxc.wxGA_PROGRESSBAR
wxGA_HORIZONTAL = wxc.wxGA_HORIZONTAL
wxGA_VERTICAL = wxc.wxGA_VERTICAL
wxGA_SMOOTH = wxc.wxGA_SMOOTH
wxSL_HORIZONTAL = wxc.wxSL_HORIZONTAL
wxSL_VERTICAL = wxc.wxSL_VERTICAL
wxSL_AUTOTICKS = wxc.wxSL_AUTOTICKS
@ -268,6 +274,10 @@ wxDF_OEMTEXT = wxc.wxDF_OEMTEXT
wxDF_FILENAME = wxc.wxDF_FILENAME
wxPORTRAIT = wxc.wxPORTRAIT
wxLANDSCAPE = wxc.wxLANDSCAPE
wxPRINT_QUALITY_HIGH = wxc.wxPRINT_QUALITY_HIGH
wxPRINT_QUALITY_MEDIUM = wxc.wxPRINT_QUALITY_MEDIUM
wxPRINT_QUALITY_LOW = wxc.wxPRINT_QUALITY_LOW
wxPRINT_QUALITY_DRAFT = wxc.wxPRINT_QUALITY_DRAFT
wxID_OPEN = wxc.wxID_OPEN
wxID_CLOSE = wxc.wxID_CLOSE
wxID_NEW = wxc.wxID_NEW
@ -332,6 +342,10 @@ wxOVERWRITE_PROMPT = wxc.wxOVERWRITE_PROMPT
wxACCEL_ALT = wxc.wxACCEL_ALT
wxACCEL_CTRL = wxc.wxACCEL_CTRL
wxACCEL_SHIFT = wxc.wxACCEL_SHIFT
wxPD_AUTO_HIDE = wxc.wxPD_AUTO_HIDE
wxPD_APP_MODAL = wxc.wxPD_APP_MODAL
wxPD_CAN_ABORT = wxc.wxPD_CAN_ABORT
wxNO_DEFAULT = wxc.wxNO_DEFAULT
wxDEFAULT = wxc.wxDEFAULT
wxDECORATIVE = wxc.wxDECORATIVE
wxROMAN = wxc.wxROMAN
@ -552,6 +566,9 @@ wxPAPER_B5_EXTRA = wxc.wxPAPER_B5_EXTRA
wxPAPER_A2 = wxc.wxPAPER_A2
wxPAPER_A3_TRANSVERSE = wxc.wxPAPER_A3_TRANSVERSE
wxPAPER_A3_EXTRA_TRANSVERSE = wxc.wxPAPER_A3_EXTRA_TRANSVERSE
wxDUPLEX_SIMPLEX = wxc.wxDUPLEX_SIMPLEX
wxDUPLEX_HORIZONTAL = wxc.wxDUPLEX_HORIZONTAL
wxDUPLEX_VERTICAL = wxc.wxDUPLEX_VERTICAL
FALSE = wxc.FALSE
false = wxc.false
TRUE = wxc.TRUE
@ -611,6 +628,13 @@ wxEVT_SCROLL_LINEDOWN = wxc.wxEVT_SCROLL_LINEDOWN
wxEVT_SCROLL_PAGEUP = wxc.wxEVT_SCROLL_PAGEUP
wxEVT_SCROLL_PAGEDOWN = wxc.wxEVT_SCROLL_PAGEDOWN
wxEVT_SCROLL_THUMBTRACK = wxc.wxEVT_SCROLL_THUMBTRACK
wxEVT_SCROLLWIN_TOP = wxc.wxEVT_SCROLLWIN_TOP
wxEVT_SCROLLWIN_BOTTOM = wxc.wxEVT_SCROLLWIN_BOTTOM
wxEVT_SCROLLWIN_LINEUP = wxc.wxEVT_SCROLLWIN_LINEUP
wxEVT_SCROLLWIN_LINEDOWN = wxc.wxEVT_SCROLLWIN_LINEDOWN
wxEVT_SCROLLWIN_PAGEUP = wxc.wxEVT_SCROLLWIN_PAGEUP
wxEVT_SCROLLWIN_PAGEDOWN = wxc.wxEVT_SCROLLWIN_PAGEDOWN
wxEVT_SCROLLWIN_THUMBTRACK = wxc.wxEVT_SCROLLWIN_THUMBTRACK
wxEVT_SIZE = wxc.wxEVT_SIZE
wxEVT_MOVE = wxc.wxEVT_MOVE
wxEVT_CLOSE_WINDOW = wxc.wxEVT_CLOSE_WINDOW
@ -685,10 +709,15 @@ wxEVT_COMMAND_LIST_ITEM_DESELECTED = wxc.wxEVT_COMMAND_LIST_ITEM_DESELECTED
wxEVT_COMMAND_LIST_KEY_DOWN = wxc.wxEVT_COMMAND_LIST_KEY_DOWN
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_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_NOTEBOOK_PAGE_CHANGING = wxc.wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING = wxc.wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING
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
__version__ = wxc.__version__
cvar = wxc.cvar
wxPyDefaultPosition = wxPointPtr(wxc.cvar.wxPyDefaultPosition)
@ -728,6 +757,12 @@ def _checkForCallback(obj, name, event, theID=-1):
except: pass
else: obj.Connect(theID, -1, event, cb)
## def _checkClassCallback(obj, name):
## try: cb = getattr(obj, name)
## except: pass
## else: obj._addCallback(name, cb)
def _StdWindowCallbacks(win):
_checkForCallback(win, "OnChar", wxEVT_CHAR)
_checkForCallback(win, "OnSize", wxEVT_SIZE)
@ -836,6 +871,9 @@ def EVT_NAVIGATION_KEY(win, func):
def EVT_IDLE(win, func):
win.Connect(-1, -1, wxEVT_IDLE, func)
def EVT_UPDATE_UI(win, id, func):
win.Connect(id, -1, wxEVT_UPDATE_UI, func)
# Mouse Events
def EVT_LEFT_DOWN(win, func):
@ -1207,6 +1245,9 @@ def EVT_LIST_SET_INFO(win, id, func):
def EVT_LIST_ITEM_SELECTED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_SELECTED, func)
def EVT_LIST_ITEM_ACTIVATED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_ACTIVATED, func)
def EVT_LIST_ITEM_DESELECTED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_DESELECTED, func)
@ -1219,6 +1260,19 @@ def EVT_LIST_INSERT_ITEM(win, id, func):
def EVT_LIST_COL_CLICK(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_LIST_COL_CLICK, func)
#wxSplitterWindow
def EVT_SPLITTER_SASH_POS_CHANGING(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING, func)
def EVT_SPLITTER_SASH_POS_CHANGED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED, func)
def EVT_SPLITTER_UNSPLIT(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_UNSPLIT, func)
def EVT_SPLITTER_DOUBLECLICKED(win, id, func):
win.Connect(id, -1, wxEVT_COMMAND_SPLITTER_DOUBLECLICKED, func)
#----------------------------------------------------------------------
@ -1328,85 +1382,3 @@ class wxApp(wxPyApp):
#----------------------------------------------------------------------------
#
# $Log$
# Revision 1.10 1999/05/02 02:06:37 RD
# More for wxPython 2.0b9 (hopefully the last...)
#
# Revision 1.12 1999/04/30 03:29:18 RD
#
# wxPython 2.0b9, first phase (win32)
# Added gobs of stuff, see wxPython/README.txt for details
#
# Revision 1.11.4.2 1999/03/28 06:35:01 RD
#
# wxPython 2.0b8
# Python thread support
# various minor additions
# various minor fixes
#
# Revision 1.11.4.1 1999/03/27 23:29:13 RD
#
# wxPython 2.0b8
# Python thread support
# various minor additions
# various minor fixes
#
# Revision 1.11 1999/02/20 09:02:55 RD
# Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
# window handle. If you can get the window handle into the python code,
# it should just work... More news on this later.
#
# Added wxImageList, wxToolTip.
#
# Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
# wxRegConfig class.
#
# As usual, some bug fixes, tweaks, etc.
#
# Revision 1.10 1999/02/01 00:10:39 RD
#
# Added the missing EVT_LIST_ITEM_SELECTED and friends.
#
# Revision 1.9 1999/01/30 07:30:09 RD
#
# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
#
# Various cleanup, tweaks, minor additions, etc. to maintain
# compatibility with the current wxWindows.
#
# Revision 1.8 1999/01/29 21:13:42 HH
# Added aliases for wxDefaultPosition and wxDefaultSize (from wxPy..) in _extras,
# so that C++ documentation applies.
#
# Revision 1.7 1998/11/25 08:45:21 RD
#
# Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
# Added events for wxGrid
# Other various fixes and additions
#
# Revision 1.6 1998/11/16 00:00:52 RD
# Generic treectrl for wxPython/GTK compiles...
#
# Revision 1.5 1998/10/20 07:38:02 RD
# bug fix
#
# Revision 1.4 1998/10/20 06:43:54 RD
# New wxTreeCtrl wrappers (untested)
# some changes in helpers
# etc.
#
# Revision 1.3 1998/10/02 06:40:33 RD
#
# Version 0.4 of wxPython for MSW.
#
# Revision 1.2 1998/08/18 19:48:12 RD
# more wxGTK compatibility things.
#
# It builds now but there are serious runtime problems...
#
# Revision 1.1 1998/08/09 08:25:49 RD
# Initial version
#
#

360
utils/wxPython/src/printfw.i Normal file
View File

@ -0,0 +1,360 @@
/////////////////////////////////////////////////////////////////////////////
// Name: printfw.i
// Purpose: Printing Framework classes
//
// Author: Robin Dunn
//
// Created: 7-May-1999
// RCS-ID: $Id$
// Copyright: (c) 1998 by Total Control Software
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
%module printfw
%{
#include "helpers.h"
#include <wx/print.h>
#include <wx/printdlg.h>
%}
//----------------------------------------------------------------------
%include typemaps.i
%include my_typemaps.i
// Import some definitions of other classes, etc.
%import _defs.i
%import misc.i
%import windows.i
%import gdi.i
%import cmndlgs.i
%import frames.i
%pragma(python) code = "import wx"
//----------------------------------------------------------------------
class wxPrintData {
public:
wxPrintData();
~wxPrintData();
int GetNoCopies();
bool GetCollate();
int GetOrientation();
const wxString& GetPrinterName();
bool GetColour();
wxDuplexMode GetDuplex();
wxPaperSize GetPaperId();
const wxSize& GetPaperSize();
wxPrintQuality GetQuality();
void SetNoCopies(int v);
void SetCollate(bool flag);
void SetOrientation(int orient);
void SetPrinterName(const wxString& name);
void SetColour(bool colour);
void SetDuplex(wxDuplexMode duplex);
void SetPaperId(wxPaperSize sizeId);
void SetPaperSize(const wxSize& sz);
void SetQuality(wxPrintQuality quality);
// // PostScript-specific data
// const wxString& GetPrinterCommand();
// const wxString& GetPrinterOptions();
// const wxString& GetPreviewCommand();
// const wxString& GetFilename();
// const wxString& GetFontMetricPath();
// double GetPrinterScaleX();
// double GetPrinterScaleY();
// long GetPrinterTranslateX();
// long GetPrinterTranslateY();
// wxPrintMode GetPrintMode();
// void SetPrinterCommand(const wxString& command);
// void SetPrinterOptions(const wxString& options);
// void SetPreviewCommand(const wxString& command);
// void SetFilename(const wxString& filename);
// void SetFontMetricPath(const wxString& path);
// void SetPrinterScaleX(double x);
// void SetPrinterScaleY(double y);
// void SetPrinterScaling(double x, double y);
// void SetPrinterTranslateX(long x);
// void SetPrinterTranslateY(long y);
// void SetPrinterTranslation(long x, long y);
// void SetPrintMode(wxPrintMode printMode);
};
//----------------------------------------------------------------------
class wxPageSetupDialogData {
public:
wxPageSetupDialogData();
~wxPageSetupDialogData();
void EnableHelp(bool flag);
void EnableMargins(bool flag);
void EnableOrientation(bool flag);
void EnablePaper(bool flag);
void EnablePrinter(bool flag);
bool GetDefaultMinMargins();
bool GetEnableMargins();
bool GetEnableOrientation();
bool GetEnablePaper();
bool GetEnablePrinter();
bool GetEnableHelp();
bool GetDefaultInfo();
wxPoint GetMarginTopLeft();
wxPoint GetMarginBottomRight();
wxPoint GetMinMarginTopLeft();
wxPoint GetMinMarginBottomRight();
wxPaperSize GetPaperId();
wxSize GetPaperSize();
%addmethods {
%new wxPrintData* GetPrintData() {
return new wxPrintData(self->GetPrintData()); // force a copy
}
}
void SetDefaultInfo(bool flag);
void SetDefaultMinMargins(bool flag);
void SetMarginTopLeft(const wxPoint& pt);
void SetMarginBottomRight(const wxPoint& pt);
void SetMinMarginTopLeft(const wxPoint& pt);
void SetMinMarginBottomRight(const wxPoint& pt);
void SetPaperId(wxPaperSize& id);
void SetPaperSize(const wxSize& size);
void SetPrintData(const wxPrintData& printData);
};
class wxPageSetupDialog : public wxDialog {
public:
wxPageSetupDialog(wxWindow* parent, wxPageSetupDialogData* data = NULL);
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
wxPageSetupDialogData& GetPageSetupData();
int ShowModal();
};
//----------------------------------------------------------------------
class wxPrintDialogData {
public:
wxPrintDialogData();
~wxPrintDialogData();
void EnableHelp(bool flag);
void EnablePageNumbers(bool flag);
void EnablePrintToFile(bool flag);
void EnableSelection(bool flag);
bool GetAllPages();
bool GetCollate();
int GetFromPage();
int GetMaxPage();
int GetMinPage();
int GetNoCopies();
%addmethods {
%new wxPrintData* GetPrintData() {
return new wxPrintData(self->GetPrintData()); // force a copy
}
}
bool GetPrintToFile();
int GetToPage();
void SetCollate(bool flag);
void SetFromPage(int page);
void SetMaxPage(int page);
void SetMinPage(int page);
void SetNoCopies(int n);
void SetPrintData(const wxPrintData& printData);
void SetPrintToFile(bool flag);
void SetSetupDialog(bool flag);
void SetToPage(int page);
};
class wxPrintDialog : public wxDialog {
public:
wxPrintDialog(wxWindow* parent, wxPrintDialogData* data = NULL);
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
wxPrintDialogData& GetPrintDialogData();
%new wxDC* GetPrintDC();
int ShowModal();
};
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// Custom wxPrintout class that knows how to call python
%{
class wxPyPrintout : public wxPrintout {
public:
wxPyPrintout(const wxString& title) : wxPrintout(title) {}
PYCALLBACK_BOOL_INTINT(wxPrintout, OnBeginDocument);
PYCALLBACK__(wxPrintout, OnEndDocument);
PYCALLBACK__(wxPrintout, OnBeginPrinting);
PYCALLBACK__(wxPrintout, OnEndPrinting);
PYCALLBACK__(wxPrintout, OnPreparePrinting);
PYCALLBACK_BOOL_INT_pure(wxPrintout, OnPrintPage);
PYCALLBACK_BOOL_INT(wxPrintout, HasPage);
// Since this one would be tough and ugly to do with the Macros...
void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
bool hadErr = false;
if (m_myInst.findCallback("GetPageInfo")) {
PyObject* result = m_myInst.callCallbackObj(Py_BuildValue("()"));
if (result && PyTuple_Check(result) && PyTuple_Size(result) == 4) {
PyObject* val;
val = PyTuple_GetItem(result, 0);
if (PyInt_Check(val)) *minPage = PyInt_AsLong(val);
else hadErr = true;
val = PyTuple_GetItem(result, 1);
if (PyInt_Check(val)) *maxPage = PyInt_AsLong(val);
else hadErr = true;
val = PyTuple_GetItem(result, 2);
if (PyInt_Check(val)) *pageFrom = PyInt_AsLong(val);
else hadErr = true;
val = PyTuple_GetItem(result, 3);
if (PyInt_Check(val)) *pageTo = PyInt_AsLong(val);
else hadErr = true;
}
else
hadErr = true;
if (hadErr) {
PyErr_SetString(PyExc_TypeError, "GetPageInfo should return a tuple of 4 integers.");
PyErr_Print();
}
Py_DECREF(result);
#ifdef WXP_WITH_THREAD
PyEval_SaveThread();
#endif
}
else
wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
}
void base_GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
}
PYPRIVATE;
};
%}
// Now define the custom class for SWIGging
%name(wxPrintout) class wxPyPrintout {
public:
wxPyPrintout(const char* title = "Printout");
void _setSelf(PyObject* self);
%pragma(python) addtomethod = "__init__:self._setSelf(self)"
%addmethods {
void Destroy() {
delete self;
}
}
wxDC* GetDC();
void GetPageSizeMM(int *OUTPUT, int *OUTPUT);
void GetPageSizePixels(int *OUTPUT, int *OUTPUT);
void GetPPIPrinter(int *OUTPUT, int *OUTPUT);
void GetPPIScreen(int *OUTPUT, int *OUTPUT);
bool IsPreview();
bool base_OnBeginDocument(int startPage, int endPage);
void base_OnEndDocument();
void base_OnBeginPrinting();
void base_OnEndPrinting();
void base_OnPreparePrinting();
void base_GetPageInfo(int *OUTPUT, int *OUTPUT, int *OUTPUT, int *OUTPUT);
bool base_HasPage(int page);
};
//----------------------------------------------------------------------
class wxPrinter {
public:
wxPrinter(wxPrintDialogData* data = NULL);
~wxPrinter();
// bool Abort();
void CreateAbortWindow(wxWindow* parent, wxPyPrintout* printout);
wxPrintDialogData& GetPrintDialogData();
bool Print(wxWindow *parent, wxPyPrintout *printout, int prompt=TRUE);
wxDC* PrintDialog(wxWindow *parent);
void ReportError(wxWindow *parent, wxPyPrintout *printout, char* message);
bool Setup(wxWindow *parent);
};
//----------------------------------------------------------------------
class wxPrintPreview {
public:
wxPrintPreview(wxPyPrintout* printout, wxPyPrintout* printoutForPrinting, wxPrintData* data=NULL);
// ~wxPrintPreview(); **** ????
wxWindow* GetCanvas();
int GetCurrentPage();
wxFrame * GetFrame();
int GetMaxPage();
int GetMinPage();
wxPrintDialogData& GetPrintDialogData();
wxPyPrintout * GetPrintout();
wxPyPrintout * GetPrintoutForPrinting();
int GetZoom();
bool Ok();
bool Print(bool prompt);
void SetCanvas(wxWindow* window);
void SetCurrentPage(int pageNum);
void SetFrame(wxFrame *frame);
void SetPrintout(wxPyPrintout *printout);
void SetZoom(int percent);
};
//----------------------------------------------------------------------
class wxPreviewFrame : public wxFrame {
public:
wxPreviewFrame(wxPrintPreview* preview, wxFrame* parent, const wxString& title,
const wxPoint& pos = wxPyDefaultPosition,
const wxSize& size = wxPyDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
char* name = "frame");
%pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
void Initialize();
// **** need to use derived class so these can be properly overridden:
//void CreateControlBar()
//void CreateCanvas()
};
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------

63
utils/wxPython/src/utils.i
View File

@ -128,57 +128,12 @@ public:
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.5 1999/05/01 04:40:57 RD
// wxPython 2.0b9, second phase (gtk)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.4 1999/04/30 03:29:19 RD
//
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.3.4.1 1999/03/27 23:29:15 RD
//
// wxPython 2.0b8
// Python thread support
// various minor additions
// various minor fixes
//
// Revision 1.3 1999/02/25 07:08:36 RD
//
// wxPython version 2.0b5
//
// Revision 1.2 1999/02/20 09:03:02 RD
// Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
// window handle. If you can get the window handle into the python code,
// it should just work... More news on this later.
//
// Added wxImageList, wxToolTip.
//
// Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
// wxRegConfig class.
//
// As usual, some bug fixes, tweaks, etc.
//
// Revision 1.1 1998/12/15 20:41:23 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
%init %{
wxClassInfo::CleanUpClasses();
wxClassInfo::InitializeClasses();
%}
//---------------------------------------------------------------------------

47
utils/wxPython/src/windows.i
View File

@ -29,6 +29,8 @@
%import gdi.i
%pragma(python) code = "import wx"
//%pragma(python) code = "import controls"
//%pragma(python) code = "wxButtonPtr = controls.wxWindowPtr"
//---------------------------------------------------------------------------
@ -64,10 +66,10 @@ public:
void CaptureMouse();
void Center(int direction = wxHORIZONTAL);
void Centre(int direction = wxHORIZONTAL);
void CentreOnParent(int direction = wxHORIZONTAL );
void CenterOnParent(int direction = wxHORIZONTAL );
%name(ClientToScreenXY)void ClientToScreen(int *BOTH, int *BOTH);
#ifndef __WXGTK__
wxPoint ClientToScreen(const wxPoint& pt);
#endif
bool Close(int force = FALSE);
bool Destroy();
void DestroyChildren();
@ -85,9 +87,6 @@ public:
%name(GetClientSizeTuple) void GetClientSize(int *OUTPUT, int *OUTPUT);
wxSize GetClientSize();
wxLayoutConstraints * GetConstraints();
#ifdef __WXMSW__
wxButton* GetDefaultItem();
#endif
//wxEvtHandler* GetEventHandler();
wxFont& GetFont();
@ -95,6 +94,7 @@ public:
wxWindow * GetGrandParent();
int GetId();
wxString GetLabel();
void SetLabel(const wxString& label);
wxString GetName();
wxWindow * GetParent();
%name(GetPositionTuple) void GetPosition(int *OUTPUT, int *OUTPUT);
@ -111,10 +111,12 @@ public:
const wxFont* font = NULL); //, bool use16 = FALSE)
wxString GetTitle();
long GetWindowStyleFlag();
bool Hide();
void InitDialog();
bool IsEnabled();
bool IsRetained();
bool IsShown();
bool IsTopLevel();
void Layout();
bool LoadFromResource(wxWindow* parent, const wxString& resourceName, const wxResourceTable* resourceTable = NULL);
void Lower();
@ -129,10 +131,10 @@ public:
void Raise();
void Refresh(bool eraseBackground = TRUE, const wxRect* rect = NULL);
void ReleaseMouse();
bool Reparent( wxWindow* newParent );
%name(ScreenToClientXY)void ScreenToClient(int *BOTH, int *BOTH);
#ifndef __WXGTK__
wxPoint ScreenToClient(const wxPoint& pt);
#endif
void ScrollWindow(int dx, int dy, const wxRect* rect = NULL);
void SetAcceleratorTable(const wxAcceleratorTable& accel);
@ -187,11 +189,17 @@ public:
};
%pragma(python) code = "
def wxDLG_PNT(win, point):
return win.ConvertDialogPointToPixels(point)
def wxDLG_PNT(win, point_or_x, y=None):
if y is None:
return win.ConvertDialogPointToPixels(point_or_x)
else:
return win.ConvertDialogPointToPixels(wxPoint(point_or_x, y))
def wxDLG_SZE(win, size):
return win.ConvertDialogSizeToPixels(size)
def wxDLG_SZE(win, size_width, height=None):
if height is None:
return win.ConvertDialogSizeToPixels(size_width)
else:
return win.ConvertDialogSizeToPixels(wxSize(size_width, height))
"
#ifdef __WXMSW__
@ -227,7 +235,17 @@ public:
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
void InitDialog();
wxButton* GetDefaultItem();
void SetDefaultItem(wxButton *btn);
// fix a SWIG turd...
%pragma(python) addtoclass = "
def GetDefaultItem(self):
import controls
val = windowsc.wxPanel_GetDefaultItem(self.this)
val = controls.wxButtonPtr(val)
return val
"
};
//---------------------------------------------------------------------------
@ -261,7 +279,7 @@ public:
//---------------------------------------------------------------------------
class wxScrolledWindow : public wxWindow {
class wxScrolledWindow : public wxPanel {
public:
wxScrolledWindow(wxWindow* parent,
const wxWindowID id = -1,
@ -401,7 +419,12 @@ public:
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.17 1999/06/22 07:03:03 RD
// wxPython 2.1b1 for wxMSW (wxGTK coming soon)
// Lots of changes, see the README.txt for details...
//
// Revision 1.16 1999/05/15 00:56:04 RD
//
// fixes for GetReturnCode/SetReturnCode
//
// Revision 1.15 1999/04/30 03:29:19 RD

97
utils/wxPython/src/windows2.i
View File

@ -204,10 +204,12 @@ enum {
//---------------------------------------------------------------------------
class wxNotebookEvent : public wxCommandEvent {
class wxNotebookEvent : public wxNotifyEvent {
public:
int GetSelection();
int GetOldSelection();
void SetOldSelection(int page);
void SetSelection(int page);
};
@ -251,7 +253,7 @@ public:
bool bSelect = FALSE,
int imageId = -1);
#endif
wxNotebookPage *GetPage(int nPage);
/*wxNotebookPage*/ wxWindow *GetPage(int nPage);
%addmethods {
void ResizeChildren() {
@ -265,6 +267,18 @@ public:
//---------------------------------------------------------------------------
class wxSplitterEvent : public wxCommandEvent {
public:
int GetSashPosition();
int GetX();
int GetY();
wxWindow* GetWindowBeingRemoved();
void SetSashPosition(int pos);
}
class wxSplitterWindow : public wxWindow {
public:
wxSplitterWindow(wxWindow* parent, wxWindowID id,
@ -285,12 +299,6 @@ public:
void Initialize(wxWindow* window);
bool IsSplit();
// TODO: How to handle callbacks that don't come from
// event system???
//
//void OnDoubleClickSash(int x, int y);
//bool OnSashPositionChange(int newSashPosition);
//void OnUnsplit(wxWindow* removed);
void SetBorderSize(int width);
void SetSashPosition(int position, int redraw = TRUE);
@ -338,76 +346,3 @@ public:
#endif
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//
// $Log$
// Revision 1.11 1999/05/15 00:56:05 RD
// fixes for GetReturnCode/SetReturnCode
//
// Revision 1.10 1999/04/30 03:29:19 RD
//
// wxPython 2.0b9, first phase (win32)
// Added gobs of stuff, see wxPython/README.txt for details
//
// Revision 1.9.4.1 1999/03/16 06:04:05 RD
//
// wxPython 2.0b7
//
// Revision 1.9 1999/02/25 07:08:36 RD
//
// wxPython version 2.0b5
//
// Revision 1.8 1998/12/17 18:05:53 RD
//
// wxPython 0.5.2
// Minor fixes and SWIG code generation for RR's changes. MSW and GTK
// versions are much closer now!
//
// Revision 1.7 1998/12/15 20:41:25 RD
// Changed the import semantics from "from wxPython import *" to "from
// wxPython.wx import *" This is for people who are worried about
// namespace pollution, they can use "from wxPython import wx" and then
// prefix all the wxPython identifiers with "wx."
//
// Added wxTaskbarIcon for wxMSW.
//
// Made the events work for wxGrid.
//
// Added wxConfig.
//
// Added wxMiniFrame for wxGTK, (untested.)
//
// Changed many of the args and return values that were pointers to gdi
// objects to references to reflect changes in the wxWindows API.
//
// Other assorted fixes and additions.
//
// Revision 1.6 1998/11/25 08:45:28 RD
//
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
// Added events for wxGrid
// Other various fixes and additions
//
// Revision 1.5 1998/11/03 09:21:57 RD
// fixed a typo
//
// Revision 1.4 1998/10/02 06:40:43 RD
//
// Version 0.4 of wxPython for MSW.
//
// Revision 1.3 1998/08/18 19:48:20 RD
// more wxGTK compatibility things.
//
// It builds now but there are serious runtime problems...
//
// Revision 1.2 1998/08/15 07:36:50 RD
// - Moved the header in the .i files out of the code that gets put into
// the .cpp files. It caused CVS conflicts because of the RCS ID being
// different each time.
//
// - A few minor fixes.
//
// Revision 1.1 1998/08/09 08:25:52 RD
// Initial version
//
//

8
utils/wxPython/src/wx.i
View File

@ -26,6 +26,7 @@
%include _defs.i
%import misc.i
%import misc2.i
%import windows.i
%import events.i
%import gdi.i
@ -38,6 +39,7 @@
%import frames.i
%import windows3.i
%import image.i
%import printfw.i
%native(_wxStart) __wxStart;
@ -45,7 +47,7 @@
//---------------------------------------------------------------------------
#define __version__ "2.0b9"
#define __version__ "2.1b1"
wxPoint wxPyDefaultPosition;
wxSize wxPyDefaultSize;
@ -105,6 +107,7 @@ extern "C" SWIGEXPORT(void,initwindowsc)();
extern "C" SWIGEXPORT(void,initwindows2c)();
extern "C" SWIGEXPORT(void,initeventsc)();
extern "C" SWIGEXPORT(void,initmiscc)();
extern "C" SWIGEXPORT(void,initmisc2c)();
extern "C" SWIGEXPORT(void,initgdic)();
extern "C" SWIGEXPORT(void,initmdic)();
extern "C" SWIGEXPORT(void,initcontrolsc)();
@ -114,6 +117,7 @@ extern "C" SWIGEXPORT(void,initstattoolc)();
extern "C" SWIGEXPORT(void,initframesc)();
extern "C" SWIGEXPORT(void,initwindows3c)();
extern "C" SWIGEXPORT(void,initimagec)();
extern "C" SWIGEXPORT(void,initprintfwc)();
#ifndef SEPARATE
extern "C" SWIGEXPORT(void,initutilsc)();
extern "C" SWIGEXPORT(void,initglcanvasc)();
@ -135,6 +139,7 @@ extern "C" SWIGEXPORT(void,initglcanvasc)();
initwindows2c();
initeventsc();
initmiscc();
initmisc2c();
initgdic();
initmdic();
initcontrolsc();
@ -144,6 +149,7 @@ extern "C" SWIGEXPORT(void,initglcanvasc)();
initframesc();
initwindows3c();
initimagec();
initprintfwc();
#ifndef SEPARATE
initutilsc();
#ifdef WITH_GLCANVAS