Converted the main demo framework files to the new namespace, (none of
the actual samples yet except NewNamespace...) Added the GridDragAndDrop sample Fixed the NewNamespace sample to actually have something to display git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_4_BRANCH@20956 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
@@ -1,12 +1,12 @@
|
||||
import sys
|
||||
|
||||
from wxPython.wx import *
|
||||
from wxPython.html import *
|
||||
import wxPython.lib.wxpTag
|
||||
import wx
|
||||
import wx.html
|
||||
import wx.lib.wxpTag
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
class MyAboutBox(wxDialog):
|
||||
class MyAboutBox(wx.Dialog):
|
||||
text = '''
|
||||
<html>
|
||||
<body bgcolor="#AC76DE">
|
||||
@@ -29,36 +29,40 @@ sit back and enjoy. Be sure to take a peek at the source code for each
|
||||
demo item so you can learn how to use the classes yourself.</p>
|
||||
|
||||
<p><b>wxPython</b> is brought to you by <b>Robin Dunn</b> and<br>
|
||||
<b>Total Control Software,</b> Copyright (c) 1997-2002.</p>
|
||||
<b>Total Control Software,</b> Copyright (c) 1997-2003.</p>
|
||||
|
||||
<p>
|
||||
<font size="-1">Please see <i>license.txt</i> for licensing information.</font>
|
||||
</p>
|
||||
|
||||
<p><wxp class="wxButton">
|
||||
<p><wxp module="wx" class="Button">
|
||||
<param name="label" value="Okay">
|
||||
<param name="id" value="wxID_OK">
|
||||
<param name="id" value="ID_OK">
|
||||
</wxp></p>
|
||||
</center>
|
||||
</body>
|
||||
</html>
|
||||
'''
|
||||
def __init__(self, parent):
|
||||
wxDialog.__init__(self, parent, -1, 'About the wxPython demo',)
|
||||
html = wxHtmlWindow(self, -1, size=(420, -1))
|
||||
wx.Dialog.__init__(self, parent, -1, 'About the wxPython demo',)
|
||||
html = wx.html.HtmlWindow(self, -1, size=(420, -1))
|
||||
py_version = sys.version.split()[0]
|
||||
html.SetPage(self.text % (wx.__version__, py_version))
|
||||
btn = html.FindWindowById(wxID_OK)
|
||||
html.SetPage(self.text % (wx.VERSION_STRING, py_version))
|
||||
btn = html.FindWindowById(wx.ID_OK)
|
||||
btn.SetDefault()
|
||||
ir = html.GetInternalRepresentation()
|
||||
html.SetSize( (ir.GetWidth()+25, ir.GetHeight()+25) )
|
||||
self.SetClientSize(html.GetSize())
|
||||
self.CentreOnParent(wxBOTH)
|
||||
self.CentreOnParent(wx.BOTH)
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
app = wx.PySimpleApp()
|
||||
dlg = MyAboutBox(None)
|
||||
dlg.ShowModal()
|
||||
dlg.Destroy()
|
||||
app.MainLoop()
|
||||
|
||||
|
||||
104
wxPython/demo/GridDragAndDrop.py
Normal file
104
wxPython/demo/GridDragAndDrop.py
Normal file
@@ -0,0 +1,104 @@
|
||||
"""
|
||||
Example showing how to make a grid a drop target for files.
|
||||
|
||||
"""
|
||||
|
||||
from wxPython.wx import *
|
||||
from wxPython.grid import *
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
# Set VIRTUAL to 1 to use a virtual grid
|
||||
|
||||
VIRTUAL = 1
|
||||
|
||||
class GridFileDropTarget(wxFileDropTarget):
|
||||
def __init__(self, grid):
|
||||
wxFileDropTarget.__init__(self)
|
||||
self.grid = grid
|
||||
|
||||
def OnDropFiles(self, x, y, filenames):
|
||||
# the x,y coordinates here are Unscrolled coordinates. They must be changed
|
||||
# to scrolled coordinates.
|
||||
x, y = self.grid.CalcUnscrolledPosition(x, y)
|
||||
|
||||
# now we need to get the row and column from the grid
|
||||
# but we need to first remove the RowLabel and ColumnLabel
|
||||
# bounding boxes
|
||||
# Why this isn't done for us, I'll never know...
|
||||
x = x - self.grid.GetGridRowLabelWindow().GetRect().width
|
||||
y = y - self.grid.GetGridColLabelWindow().GetRect().height
|
||||
col = self.grid.XToCol(x)
|
||||
row = self.grid.YToRow(y)
|
||||
|
||||
if row > -1 and col > -1:
|
||||
self.grid.SetCellValue(row, col, filenames[0])
|
||||
self.grid.AutoSizeColumn(col)
|
||||
self.grid.Refresh()
|
||||
|
||||
|
||||
|
||||
class FooTable(wxPyGridTableBase):
|
||||
def __init__(self):
|
||||
wxPyGridTableBase.__init__(self)
|
||||
self.dropTargets = {(0,0):"Drag",
|
||||
(1,0):"A",
|
||||
(2,0):"File",
|
||||
(3,0):"To",
|
||||
(4,0):"A",
|
||||
(5,0):"Cell"}
|
||||
def GetNumberCols(self):
|
||||
return 100
|
||||
def GetNumberRows(self):
|
||||
return 100
|
||||
def GetValue(self, row, col):
|
||||
return self.dropTargets.get((row, col), "")
|
||||
|
||||
|
||||
|
||||
class SimpleGrid(wxGrid):
|
||||
def __init__(self, parent, log):
|
||||
wxGrid.__init__(self, parent, -1)
|
||||
self.log = log
|
||||
self.moveTo = None
|
||||
if VIRTUAL:
|
||||
self.table = FooTable()
|
||||
self.SetTable(self.table)
|
||||
else:
|
||||
self.CreateGrid(25, 25)
|
||||
|
||||
# set the drag and drop target
|
||||
dropTarget = GridFileDropTarget(self)
|
||||
self.SetDropTarget(dropTarget)
|
||||
self.EnableDragRowSize()
|
||||
self.EnableDragColSize()
|
||||
|
||||
def SetCellValue(self, row, col, value):
|
||||
if VIRTUAL:
|
||||
self.table.dropTargets[row, col] = value
|
||||
else:
|
||||
wxGrid.SetCellValue(self, row, col, value)
|
||||
|
||||
|
||||
|
||||
class TestFrame(wxFrame):
|
||||
def __init__(self, parent, log):
|
||||
wxFrame.__init__(self, parent, -1, "DragAndDrop Grid", size=(640,480))
|
||||
grid = SimpleGrid(self, log)
|
||||
|
||||
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
if __name__ == '__main__':
|
||||
import sys
|
||||
app = wxPySimpleApp()
|
||||
frame = TestFrame(None, sys.stdout)
|
||||
frame.Show(True)
|
||||
app.MainLoop()
|
||||
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -12,10 +12,8 @@
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
import sys, os, time
|
||||
from wxPython.wx import *
|
||||
from wxPython.html import wxHtmlWindow
|
||||
|
||||
##from wxPython.stc import *
|
||||
import wx
|
||||
import wx.html
|
||||
|
||||
import images
|
||||
|
||||
@@ -214,9 +212,9 @@ _treeList = [
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
class MyLog(wxPyLog):
|
||||
class MyLog(wx.PyLog):
|
||||
def __init__(self, textCtrl, logTime=0):
|
||||
wxPyLog.__init__(self)
|
||||
wx.PyLog.__init__(self)
|
||||
self.tc = textCtrl
|
||||
self.logTime = logTime
|
||||
|
||||
@@ -228,7 +226,7 @@ class MyLog(wxPyLog):
|
||||
self.tc.AppendText(message + '\n')
|
||||
|
||||
|
||||
class MyTP(wxPyTipProvider):
|
||||
class MyTP(wx.PyTipProvider):
|
||||
def GetTip(self):
|
||||
return "This is my tip"
|
||||
|
||||
@@ -241,12 +239,12 @@ def opj(path):
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
class wxPythonDemo(wxFrame):
|
||||
class wxPythonDemo(wx.Frame):
|
||||
overviewText = "wxPython Overview"
|
||||
|
||||
def __init__(self, parent, id, title):
|
||||
wxFrame.__init__(self, parent, -1, title, size = (800, 600),
|
||||
style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
|
||||
wx.Frame.__init__(self, parent, -1, title, size = (800, 600),
|
||||
style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)
|
||||
|
||||
self.cwd = os.getcwd()
|
||||
self.curOverview = ""
|
||||
@@ -255,98 +253,97 @@ class wxPythonDemo(wxFrame):
|
||||
icon = images.getMondrianIcon()
|
||||
self.SetIcon(icon)
|
||||
|
||||
if wxPlatform == '__WXMSW__':
|
||||
if wx.Platform == '__WXMSW__':
|
||||
# setup a taskbar icon, and catch some events from it
|
||||
self.tbicon = wxTaskBarIcon()
|
||||
self.tbicon = wx.TaskBarIcon()
|
||||
self.tbicon.SetIcon(icon, "wxPython Demo")
|
||||
EVT_TASKBAR_LEFT_DCLICK(self.tbicon, self.OnTaskBarActivate)
|
||||
EVT_TASKBAR_RIGHT_UP(self.tbicon, self.OnTaskBarMenu)
|
||||
EVT_MENU(self.tbicon, self.TBMENU_RESTORE, self.OnTaskBarActivate)
|
||||
EVT_MENU(self.tbicon, self.TBMENU_CLOSE, self.OnTaskBarClose)
|
||||
wx.EVT_TASKBAR_LEFT_DCLICK(self.tbicon, self.OnTaskBarActivate)
|
||||
wx.EVT_TASKBAR_RIGHT_UP(self.tbicon, self.OnTaskBarMenu)
|
||||
wx.EVT_MENU(self.tbicon, self.TBMENU_RESTORE, self.OnTaskBarActivate)
|
||||
wx.EVT_MENU(self.tbicon, self.TBMENU_CLOSE, self.OnTaskBarClose)
|
||||
|
||||
wxCallAfter(self.ShowTip)
|
||||
wx.CallAfter(self.ShowTip)
|
||||
|
||||
self.otherWin = None
|
||||
EVT_IDLE(self, self.OnIdle)
|
||||
EVT_CLOSE(self, self.OnCloseWindow)
|
||||
EVT_ICONIZE(self, self.OnIconfiy)
|
||||
EVT_MAXIMIZE(self, self.OnMaximize)
|
||||
wx.EVT_IDLE(self, self.OnIdle)
|
||||
wx.EVT_CLOSE(self, self.OnCloseWindow)
|
||||
wx.EVT_ICONIZE(self, self.OnIconfiy)
|
||||
wx.EVT_MAXIMIZE(self, self.OnMaximize)
|
||||
|
||||
self.Centre(wxBOTH)
|
||||
self.CreateStatusBar(1, wxST_SIZEGRIP)
|
||||
self.Centre(wx.BOTH)
|
||||
self.CreateStatusBar(1, wx.ST_SIZEGRIP)
|
||||
|
||||
splitter = wxSplitterWindow(self, -1, style=wxNO_3D|wxSP_3D)
|
||||
splitter2 = wxSplitterWindow(splitter, -1, style=wxNO_3D|wxSP_3D)
|
||||
splitter = wx.SplitterWindow(self, -1, style=wx.NO_3D|wx.SP_3D)
|
||||
splitter2 = wx.SplitterWindow(splitter, -1, style=wx.NO_3D|wx.SP_3D)
|
||||
|
||||
def EmptyHandler(evt): pass
|
||||
EVT_ERASE_BACKGROUND(splitter, EmptyHandler)
|
||||
EVT_ERASE_BACKGROUND(splitter2, EmptyHandler)
|
||||
wx.EVT_ERASE_BACKGROUND(splitter, EmptyHandler)
|
||||
wx.EVT_ERASE_BACKGROUND(splitter2, EmptyHandler)
|
||||
|
||||
# Prevent TreeCtrl from displaying all items after destruction when True
|
||||
self.dying = False
|
||||
|
||||
# Make a File menu
|
||||
self.mainmenu = wxMenuBar()
|
||||
menu = wxMenu()
|
||||
exitID = wxNewId()
|
||||
self.mainmenu = wx.MenuBar()
|
||||
menu = wx.Menu()
|
||||
exitID = wx.NewId()
|
||||
menu.Append(exitID, 'E&xit\tAlt-X', 'Get the heck outta here!')
|
||||
EVT_MENU(self, exitID, self.OnFileExit)
|
||||
wxApp_SetMacExitMenuItemId(exitID)
|
||||
wx.EVT_MENU(self, exitID, self.OnFileExit)
|
||||
wx.App_SetMacExitMenuItemId(exitID)
|
||||
self.mainmenu.Append(menu, '&File')
|
||||
|
||||
# Make a Demo menu
|
||||
menu = wxMenu()
|
||||
menu = wx.Menu()
|
||||
for item in _treeList:
|
||||
submenu = wxMenu()
|
||||
submenu = wx.Menu()
|
||||
for childItem in item[1]:
|
||||
mID = wxNewId()
|
||||
mID = wx.NewId()
|
||||
submenu.Append(mID, childItem)
|
||||
EVT_MENU(self, mID, self.OnDemoMenu)
|
||||
menu.AppendMenu(wxNewId(), item[0], submenu)
|
||||
wx.EVT_MENU(self, mID, self.OnDemoMenu)
|
||||
menu.AppendMenu(wx.NewId(), item[0], submenu)
|
||||
self.mainmenu.Append(menu, '&Demo')
|
||||
|
||||
|
||||
# Make a Help menu
|
||||
helpID = wxNewId()
|
||||
findID = wxNewId()
|
||||
findnextID = wxNewId()
|
||||
menu = wxMenu()
|
||||
helpID = wx.NewId()
|
||||
findID = wx.NewId()
|
||||
findnextID = wx.NewId()
|
||||
menu = wx.Menu()
|
||||
menu.Append(findID, '&Find\tCtrl-F', 'Find in the Demo Code')
|
||||
menu.Append(findnextID, 'Find &Next\tF3', 'Find Next')
|
||||
menu.AppendSeparator()
|
||||
menu.Append(helpID, '&About\tCtrl-H', 'wxPython RULES!!!')
|
||||
wxApp_SetMacAboutMenuItemId(helpID)
|
||||
EVT_MENU(self, helpID, self.OnHelpAbout)
|
||||
EVT_MENU(self, findID, self.OnHelpFind)
|
||||
EVT_MENU(self, findnextID, self.OnFindNext)
|
||||
EVT_COMMAND_FIND(self, -1, self.OnFind)
|
||||
EVT_COMMAND_FIND_NEXT(self, -1, self.OnFind)
|
||||
EVT_COMMAND_FIND_CLOSE(self, -1 , self.OnFindClose)
|
||||
wx.App_SetMacAboutMenuItemId(helpID)
|
||||
wx.EVT_MENU(self, helpID, self.OnHelpAbout)
|
||||
wx.EVT_MENU(self, findID, self.OnHelpFind)
|
||||
wx.EVT_MENU(self, findnextID, self.OnFindNext)
|
||||
wx.EVT_COMMAND_FIND(self, -1, self.OnFind)
|
||||
wx.EVT_COMMAND_FIND_NEXT(self, -1, self.OnFind)
|
||||
wx.EVT_COMMAND_FIND_CLOSE(self, -1 , self.OnFindClose)
|
||||
self.mainmenu.Append(menu, '&Help')
|
||||
self.SetMenuBar(self.mainmenu)
|
||||
|
||||
self.finddata = wxFindReplaceData()
|
||||
self.finddata = wx.FindReplaceData()
|
||||
|
||||
if 0:
|
||||
# This is another way to set Accelerators, in addition to
|
||||
# using the '\t<key>' syntax in the menu items.
|
||||
aTable = wxAcceleratorTable([(wxACCEL_ALT, ord('X'), exitID),
|
||||
(wxACCEL_CTRL, ord('H'), helpID),
|
||||
(wxACCEL_CTRL, ord('F'), findID),
|
||||
(wxACCEL_NORMAL, WXK_F3, findnextID)
|
||||
aTable = wx.AcceleratorTable([(wx.ACCEL_ALT, ord('X'), exitID),
|
||||
(wx.ACCEL_CTRL, ord('H'), helpID),
|
||||
(wx.ACCEL_CTRL, ord('F'), findID),
|
||||
(wx.ACCEL_NORMAL, WXK_F3, findnextID)
|
||||
])
|
||||
self.SetAcceleratorTable(aTable)
|
||||
|
||||
|
||||
# Create a TreeCtrl
|
||||
tID = wxNewId()
|
||||
tID = wx.NewId()
|
||||
self.treeMap = {}
|
||||
self.tree = wxTreeCtrl(splitter, tID,
|
||||
style=wxTR_HAS_BUTTONS |
|
||||
wxTR_HAS_VARIABLE_ROW_HEIGHT
|
||||
self.tree = wx.TreeCtrl(splitter, tID,
|
||||
style=wx.TR_HAS_BUTTONS |
|
||||
wx.TR_HAS_VARIABLE_ROW_HEIGHT
|
||||
)
|
||||
|
||||
#self.tree.SetBackgroundColour(wxNamedColour("Pink"))
|
||||
root = self.tree.AddRoot("wxPython Overview")
|
||||
firstChild = None
|
||||
for item in _treeList:
|
||||
@@ -358,57 +355,57 @@ class wxPythonDemo(wxFrame):
|
||||
|
||||
self.tree.Expand(root)
|
||||
self.tree.Expand(firstChild)
|
||||
EVT_TREE_ITEM_EXPANDED (self.tree, tID, self.OnItemExpanded)
|
||||
EVT_TREE_ITEM_COLLAPSED (self.tree, tID, self.OnItemCollapsed)
|
||||
EVT_TREE_SEL_CHANGED (self.tree, tID, self.OnSelChanged)
|
||||
EVT_LEFT_DOWN (self.tree, self.OnTreeLeftDown)
|
||||
wx.EVT_TREE_ITEM_EXPANDED (self.tree, tID, self.OnItemExpanded)
|
||||
wx.EVT_TREE_ITEM_COLLAPSED (self.tree, tID, self.OnItemCollapsed)
|
||||
wx.EVT_TREE_SEL_CHANGED (self.tree, tID, self.OnSelChanged)
|
||||
wx.EVT_LEFT_DOWN (self.tree, self.OnTreeLeftDown)
|
||||
|
||||
# Create a Notebook
|
||||
self.nb = wxNotebook(splitter2, -1, style=wxCLIP_CHILDREN)
|
||||
self.nb = wx.Notebook(splitter2, -1, style=wx.CLIP_CHILDREN)
|
||||
|
||||
# Set up a wxHtmlWindow on the Overview Notebook page
|
||||
# Set up a wx.html.HtmlWindow on the Overview Notebook page
|
||||
# we put it in a panel first because there seems to be a
|
||||
# refresh bug of some sort (wxGTK) when it is directly in
|
||||
# the notebook...
|
||||
if 0: # the old way
|
||||
self.ovr = wxHtmlWindow(self.nb, -1, size=(400, 400))
|
||||
self.ovr = wx.html.HtmlWindow(self.nb, -1, size=(400, 400))
|
||||
self.nb.AddPage(self.ovr, self.overviewText)
|
||||
|
||||
else: # hopefully I can remove this hacky code soon, see SF bug #216861
|
||||
panel = wxPanel(self.nb, -1, style=wxCLIP_CHILDREN)
|
||||
self.ovr = wxHtmlWindow(panel, -1, size=(400, 400))
|
||||
panel = wx.Panel(self.nb, -1, style=wx.CLIP_CHILDREN)
|
||||
self.ovr = wx.html.HtmlWindow(panel, -1, size=(400, 400))
|
||||
self.nb.AddPage(panel, self.overviewText)
|
||||
|
||||
def OnOvrSize(evt, ovr=self.ovr):
|
||||
ovr.SetSize(evt.GetSize())
|
||||
|
||||
EVT_SIZE(panel, OnOvrSize)
|
||||
EVT_ERASE_BACKGROUND(panel, EmptyHandler)
|
||||
wx.EVT_SIZE(panel, OnOvrSize)
|
||||
wx.EVT_ERASE_BACKGROUND(panel, EmptyHandler)
|
||||
|
||||
|
||||
self.SetOverview(self.overviewText, overview)
|
||||
|
||||
|
||||
# Set up a TextCtrl on the Demo Code Notebook page
|
||||
self.txt = wxTextCtrl(self.nb, -1,
|
||||
style = wxTE_MULTILINE|wxTE_READONLY|
|
||||
wxHSCROLL|wxTE_RICH2|wxTE_NOHIDESEL)
|
||||
self.txt = wx.TextCtrl(self.nb, -1,
|
||||
style = wx.TE_MULTILINE|wx.TE_READONLY|
|
||||
wx.HSCROLL|wx.TE_RICH2|wx.TE_NOHIDESEL)
|
||||
self.nb.AddPage(self.txt, "Demo Code")
|
||||
|
||||
|
||||
# Set up a log on the View Log Notebook page
|
||||
self.log = wxTextCtrl(splitter2, -1,
|
||||
style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
|
||||
self.log = wx.TextCtrl(splitter2, -1,
|
||||
style = wx.TE_MULTILINE|wx.TE_READONLY|wx.HSCROLL)
|
||||
|
||||
# Set the wxWindows log target to be this textctrl
|
||||
#wxLog_SetActiveTarget(wxLogTextCtrl(self.log))
|
||||
#wx.Log_SetActiveTarget(wx.LogTextCtrl(self.log))
|
||||
|
||||
# But instead of the above we want to show how to use our own wxLog class
|
||||
wxLog_SetActiveTarget(MyLog(self.log))
|
||||
# But instead of the above we want to show how to use our own wx.Log class
|
||||
wx.Log_SetActiveTarget(MyLog(self.log))
|
||||
|
||||
# for serious debugging
|
||||
#wxLog_SetActiveTarget(wxLogStderr())
|
||||
#wxLog_SetTraceMask(wxTraceMessages)
|
||||
#wx.Log_SetActiveTarget(wx.LogStderr())
|
||||
#wx.Log_SetTraceMask(wx.TraceMessages)
|
||||
|
||||
self.Show(True)
|
||||
|
||||
@@ -436,14 +433,14 @@ class wxPythonDemo(wxFrame):
|
||||
self.tree.EnsureVisible(selectedDemo)
|
||||
|
||||
|
||||
wxLogMessage('window handle: %s' % self.GetHandle())
|
||||
wx.LogMessage('window handle: %s' % self.GetHandle())
|
||||
|
||||
|
||||
#---------------------------------------------
|
||||
def WriteText(self, text):
|
||||
if text[-1:] == '\n':
|
||||
text = text[:-1]
|
||||
wxLogMessage(text)
|
||||
wx.LogMessage(text)
|
||||
|
||||
|
||||
def write(self, txt):
|
||||
@@ -452,13 +449,13 @@ class wxPythonDemo(wxFrame):
|
||||
#---------------------------------------------
|
||||
def OnItemExpanded(self, event):
|
||||
item = event.GetItem()
|
||||
wxLogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
|
||||
wx.LogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
|
||||
event.Skip()
|
||||
|
||||
#---------------------------------------------
|
||||
def OnItemCollapsed(self, event):
|
||||
item = event.GetItem()
|
||||
wxLogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
|
||||
wx.LogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
|
||||
event.Skip()
|
||||
|
||||
#---------------------------------------------
|
||||
@@ -489,7 +486,7 @@ class wxPythonDemo(wxFrame):
|
||||
if self.window is not None:
|
||||
if hasattr(self.window, "ShutdownDemo"):
|
||||
self.window.ShutdownDemo()
|
||||
wxSafeYield() # in case the page has pending events
|
||||
wx.SafeYield() # in case the page has pending events
|
||||
self.nb.DeletePage(2)
|
||||
|
||||
if itemText == self.overviewText:
|
||||
@@ -500,19 +497,19 @@ class wxPythonDemo(wxFrame):
|
||||
|
||||
else:
|
||||
if os.path.exists(itemText + '.py'):
|
||||
wxBeginBusyCursor()
|
||||
wxLogMessage("Running demo %s.py..." % itemText)
|
||||
wx.BeginBusyCursor()
|
||||
wx.LogMessage("Running demo %s.py..." % itemText)
|
||||
try:
|
||||
self.GetDemoFile(itemText + '.py')
|
||||
module = __import__(itemText, globals())
|
||||
self.SetOverview(itemText + " Overview", module.overview)
|
||||
finally:
|
||||
wxEndBusyCursor()
|
||||
wx.EndBusyCursor()
|
||||
self.tree.Refresh()
|
||||
|
||||
# in case runTest is modal, make sure things look right...
|
||||
self.nb.Refresh();
|
||||
wxSafeYield()
|
||||
wx.SafeYield()
|
||||
|
||||
self.window = module.runTest(self, self.nb, self) ###
|
||||
if self.window is not None:
|
||||
@@ -561,10 +558,10 @@ class wxPythonDemo(wxFrame):
|
||||
|
||||
def OnHelpFind(self, event):
|
||||
self.nb.SetSelection(1)
|
||||
self.finddlg = wxFindReplaceDialog(self, self.finddata, "Find",
|
||||
wxFR_NOUPDOWN |
|
||||
wxFR_NOMATCHCASE |
|
||||
wxFR_NOWHOLEWORD)
|
||||
self.finddlg = wx.FindReplaceDialog(self, self.finddata, "Find",
|
||||
wx.FR_NOUPDOWN |
|
||||
wx.FR_NOMATCHCASE |
|
||||
wx.FR_NOWHOLEWORD)
|
||||
self.finddlg.Show(True)
|
||||
|
||||
def OnFind(self, event):
|
||||
@@ -579,9 +576,9 @@ class wxPythonDemo(wxFrame):
|
||||
start = 0
|
||||
loc = textstring.find(findstring, start)
|
||||
if loc == -1:
|
||||
dlg = wxMessageDialog(self, 'Find String Not Found',
|
||||
dlg = wx.MessageDialog(self, 'Find String Not Found',
|
||||
'Find String Not Found in Demo File',
|
||||
wxOK | wxICON_INFORMATION)
|
||||
wx.OK | wx.ICON_INFORMATION)
|
||||
dlg.ShowModal()
|
||||
dlg.Destroy()
|
||||
if self.finddlg:
|
||||
@@ -631,9 +628,9 @@ class wxPythonDemo(wxFrame):
|
||||
except IOError:
|
||||
showTip, index = (1, 0)
|
||||
if showTip:
|
||||
tp = wxCreateFileTipProvider(opj("data/tips.txt"), index)
|
||||
tp = wx.CreateFileTipProvider(opj("data/tips.txt"), index)
|
||||
##tp = MyTP(0)
|
||||
showTip = wxShowTip(self, tp)
|
||||
showTip = wx.ShowTip(self, tp)
|
||||
index = tp.GetCurrentTip()
|
||||
open(opj("data/showTips"), "w").write(str( (showTip, index) ))
|
||||
|
||||
@@ -663,7 +660,7 @@ class wxPythonDemo(wxFrame):
|
||||
TBMENU_CLOSE = 1001
|
||||
|
||||
def OnTaskBarMenu(self, evt):
|
||||
menu = wxMenu()
|
||||
menu = wx.Menu()
|
||||
menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
|
||||
menu.Append(self.TBMENU_CLOSE, "Close")
|
||||
self.tbicon.PopupMenu(menu)
|
||||
@@ -673,19 +670,19 @@ class wxPythonDemo(wxFrame):
|
||||
def OnTaskBarClose(self, evt):
|
||||
self.Close()
|
||||
|
||||
# because of the way wxTaskBarIcon.PopupMenu is implemented we have to
|
||||
# because of the way wx.TaskBarIcon.PopupMenu is implemented we have to
|
||||
# prod the main idle handler a bit to get the window to actually close
|
||||
wxGetApp().ProcessIdle()
|
||||
wx.GetApp().ProcessIdle()
|
||||
|
||||
|
||||
#---------------------------------------------
|
||||
def OnIconfiy(self, evt):
|
||||
wxLogMessage("OnIconfiy")
|
||||
wx.LogMessage("OnIconfiy")
|
||||
evt.Skip()
|
||||
|
||||
#---------------------------------------------
|
||||
def OnMaximize(self, evt):
|
||||
wxLogMessage("OnMaximize")
|
||||
wx.LogMessage("OnMaximize")
|
||||
evt.Skip()
|
||||
|
||||
|
||||
@@ -694,14 +691,14 @@ class wxPythonDemo(wxFrame):
|
||||
#---------------------------------------------------------------------------
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
class MySplashScreen(wxSplashScreen):
|
||||
class MySplashScreen(wx.SplashScreen):
|
||||
def __init__(self):
|
||||
bmp = wxImage(opj("bitmaps/splash.gif")).ConvertToBitmap()
|
||||
wxSplashScreen.__init__(self, bmp,
|
||||
wxSPLASH_CENTRE_ON_SCREEN|wxSPLASH_TIMEOUT,
|
||||
bmp = wx.Image(opj("bitmaps/splash.gif")).ConvertToBitmap()
|
||||
wx.SplashScreen.__init__(self, bmp,
|
||||
wx.SPLASH_CENTRE_ON_SCREEN|wx.SPLASH_TIMEOUT,
|
||||
4000, None, -1,
|
||||
style = wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP)
|
||||
EVT_CLOSE(self, self.OnClose)
|
||||
style = wx.SIMPLE_BORDER|wx.FRAME_NO_TASKBAR|wx.STAY_ON_TOP)
|
||||
wx.EVT_CLOSE(self, self.OnClose)
|
||||
|
||||
def OnClose(self, evt):
|
||||
frame = wxPythonDemo(None, -1, "wxPython: (A Demonstration)")
|
||||
@@ -709,7 +706,7 @@ class MySplashScreen(wxSplashScreen):
|
||||
evt.Skip() # Make sure the default handler runs too...
|
||||
|
||||
|
||||
class MyApp(wxApp):
|
||||
class MyApp(wx.App):
|
||||
def OnInit(self):
|
||||
"""
|
||||
Create and show the splash screen. It will then create and show
|
||||
@@ -717,10 +714,10 @@ class MyApp(wxApp):
|
||||
"""
|
||||
|
||||
#import locale
|
||||
#self.locale = wxLocale(wxLANGUAGE_FRENCH)
|
||||
#self.locale = wx.Locale(wx.LANGUAGE_FRENCH)
|
||||
#locale.setlocale(locale.LC_ALL, 'fr')
|
||||
|
||||
wxInitAllImageHandlers()
|
||||
wx.InitAllImageHandlers()
|
||||
splash = MySplashScreen()
|
||||
splash.Show()
|
||||
return True
|
||||
@@ -735,7 +732,7 @@ def main():
|
||||
os.chdir(demoPath)
|
||||
except:
|
||||
pass
|
||||
app = MyApp(wxPlatform == "__WXMAC__")
|
||||
app = MyApp(wx.Platform == "__WXMAC__")
|
||||
app.MainLoop()
|
||||
|
||||
|
||||
@@ -744,74 +741,34 @@ def main():
|
||||
|
||||
|
||||
overview = """<html><body>
|
||||
<h2>Python</h2>
|
||||
|
||||
Python is an interpreted, interactive, object-oriented programming
|
||||
language often compared to Tcl, Perl, Scheme, or Java.
|
||||
|
||||
<p> Python combines remarkable power with very clear syntax. It has
|
||||
modules, classes, exceptions, very high level dynamic data types, and
|
||||
dynamic typing. There are interfaces to many system calls and
|
||||
libraries, and new built-in modules are easily written in C or
|
||||
C++. Python is also usable as an extension language for applications
|
||||
that need a programmable interface. <p>
|
||||
|
||||
<h2>wxWindows</h2>
|
||||
|
||||
wxWindows is a free C++ framework designed to make cross-platform
|
||||
programming child's play. Well, almost. wxWindows 2 supports Windows
|
||||
3.1/95/98/NT, Unix with GTK/Motif/Lesstif, with a Mac version
|
||||
underway. Other ports are under consideration. <p>
|
||||
|
||||
wxWindows is a set of libraries that allows C++ applications to
|
||||
compile and run on several different types of computers, with minimal
|
||||
source code changes. There is one library per supported GUI (such as
|
||||
Motif, or Windows). As well as providing a common API (Application
|
||||
Programming Interface) for GUI functionality, it provides
|
||||
functionality for accessing some commonly-used operating system
|
||||
facilities, such as copying or deleting files. wxWindows is a
|
||||
'framework' in the sense that it provides a lot of built-in
|
||||
functionality, which the application can use or replace as required,
|
||||
thus saving a great deal of coding effort. Basic data structures such
|
||||
as strings, linked lists and hash tables are also supported.
|
||||
|
||||
<p>
|
||||
<h2>wxPython</h2>
|
||||
|
||||
wxPython is a Python extension module that encapsulates the wxWindows
|
||||
GUI classes. Currently it is only available for the Win32 and GTK
|
||||
ports of wxWindows, but as soon as the other ports are brought up to
|
||||
the same level as Win32 and GTK, it should be fairly trivial to
|
||||
enable wxPython to be used with the new GUI.
|
||||
<p> wxPython is a <b>GUI toolkit</b> for the <a
|
||||
href="http://www.python.org/">Python</a> programming language. It
|
||||
allows Python programmers to create programs with a robust, highly
|
||||
functional graphical user interface, simply and easily. It is
|
||||
implemented as a Python extension module (native code) that wraps the
|
||||
popular <a href="http://wxwindows.org/front.htm">wxWindows</a> cross
|
||||
platform GUI library, which is written in C++.
|
||||
|
||||
<p>
|
||||
<p> Like Python and wxWindows, wxPython is <b>Open Source</b> which
|
||||
means that it is free for anyone to use and the source code is
|
||||
available for anyone to look at and modify. Or anyone can contribute
|
||||
fixes or enhnacments to the project.
|
||||
|
||||
The wxPython extension module attempts to mirror the class heiarchy
|
||||
of wxWindows as closely as possible. This means that there is a
|
||||
wxFrame class in wxPython that looks, smells, tastes and acts almost
|
||||
the same as the wxFrame class in the C++ version. Unfortunately,
|
||||
because of differences in the languages, wxPython doesn't match
|
||||
wxWindows exactly, but the differences should be easy to absorb
|
||||
because they are natural to Python. For example, some methods that
|
||||
return multiple values via argument pointers in C++ will return a
|
||||
tuple of values in Python.
|
||||
<p> wxPython is a <b>cross-platform</b> toolkit. This means that the
|
||||
same program will run on multiple platforms without modification.
|
||||
Currently supported platforms are 32-bit Microsoft Windows, most Unix
|
||||
or unix-like systems, and Macintosh OS X. Since the language is
|
||||
Python, wxPython programs are <b>simple, easy</b> to write and easy to
|
||||
understand.
|
||||
|
||||
<p>
|
||||
|
||||
There is still much to be done for wxPython, many classes still need
|
||||
to be mirrored. Also, wxWindows is still somewhat of a moving target
|
||||
so it is a bit of an effort just keeping wxPython up to date. On the
|
||||
other hand, there are enough of the core classes completed that
|
||||
useful applications can be written.
|
||||
|
||||
<p>
|
||||
|
||||
wxPython is close enough to the C++ version that the majority of
|
||||
the wxPython documentation is actually just notes attached to the C++
|
||||
documents that describe the places where wxPython is different. There
|
||||
is also a series of sample programs included, and a series of
|
||||
documentation pages that assist the programmer in getting started
|
||||
with wxPython.
|
||||
<p> <b>This demo</b> is not only a collection of test cases for
|
||||
wxPython, but is also designed to help you learn about and how to use
|
||||
wxPython. Each sample is listed in the tree control on the left.
|
||||
When a sample is selected in the tree then a module is loaded and run
|
||||
(usually in a tab of this notebook,) and the source code of the module
|
||||
is loaded in another tab for you to browse and learn from.
|
||||
|
||||
"""
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
|
||||
import os
|
||||
import wx
|
||||
from wx import html
|
||||
from Main import opj
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
@@ -11,7 +11,7 @@ class TestPanel(wx.Panel):
|
||||
wx.Panel.__init__(self, parent, -1)
|
||||
|
||||
hwin = html.HtmlWindow(self, -1)
|
||||
hwin.LoadFile(os.path.join(os.path.dirname(wx.__file__), 'wx.html'))
|
||||
hwin.LoadFile(opj('data/wxPackage.html'))
|
||||
|
||||
sizer = wx.BoxSizer(wx.VERTICAL)
|
||||
sizer.Add(hwin, 1, wx.EXPAND)
|
||||
|
||||
290
wxPython/demo/data/wxPackage.html
Normal file
290
wxPython/demo/data/wxPackage.html
Normal file
@@ -0,0 +1,290 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1" ?>
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
|
||||
<meta name="generator" content="Docutils 0.2.8: http://docutils.sourceforge.net/" />
|
||||
<title>The wxPython wx Package</title>
|
||||
<meta name="author" content="Patrick K. O'Brien" />
|
||||
<meta name="organization" content="Orbtech" />
|
||||
<meta name="date" content="2003-05-08" />
|
||||
<link rel="stylesheet" href="default.css" type="text/css" />
|
||||
</head>
|
||||
<body>
|
||||
<div class="document" id="the-wxpython-wx-package">
|
||||
<h1 class="title">The wxPython wx Package</h1>
|
||||
<h2 class="subtitle" id="or-how-to-survive-the-new-wx-namespace-changes">Or, how to survive the new wx namespace changes.</h2>
|
||||
<table class="docinfo" frame="void" rules="none">
|
||||
<col class="docinfo-name" />
|
||||
<col class="docinfo-content" />
|
||||
<tbody valign="top">
|
||||
<tr><th class="docinfo-name">Author:</th>
|
||||
<td>Patrick K. O'Brien</td></tr>
|
||||
<tr><th class="docinfo-name">Contact:</th>
|
||||
<td><a class="first last reference" href="mailto:pobrien@orbtech.com">pobrien@orbtech.com</a></td></tr>
|
||||
<tr><th class="docinfo-name">Organization:</th>
|
||||
<td><a class="first last reference" href="http://www.orbtech.com/">Orbtech</a></td></tr>
|
||||
<tr><th class="docinfo-name">Date:</th>
|
||||
<td>2003-05-08</td></tr>
|
||||
<tr><th class="docinfo-name">Revision:</th>
|
||||
<td>1.1.2.4</td></tr>
|
||||
</tbody>
|
||||
</table>
|
||||
<div class="contents topic" id="contents">
|
||||
<p class="topic-title"><a name="contents">Contents</a></p>
|
||||
<ul class="simple">
|
||||
<li><a class="reference" href="#introduction" id="id1" name="id1">Introduction</a></li>
|
||||
<li><a class="reference" href="#why-change-anything" id="id2" name="id2">Why change anything?</a></li>
|
||||
<li><a class="reference" href="#what-does-the-new-wx-package-do" id="id3" name="id3">What does the new wx package do?</a></li>
|
||||
<li><a class="reference" href="#will-any-of-this-effect-my-existing-code" id="id4" name="id4">Will any of this effect my existing code?</a></li>
|
||||
<li><a class="reference" href="#how-does-the-new-wx-package-work" id="id5" name="id5">How does the new wx package work?</a></li>
|
||||
<li><a class="reference" href="#what-about-all-the-other-modules-like-grid-html-and-stc" id="id6" name="id6">What about all the other modules, like grid, html, and stc?</a></li>
|
||||
<li><a class="reference" href="#how-do-i-use-this-new-wx-package" id="id7" name="id7">How do I use this new wx package?</a></li>
|
||||
<li><a class="reference" href="#what-are-the-issues-with-converting-old-code-to-use-the-new-wx-package" id="id8" name="id8">What are the issues with converting old code to use the new wx package?</a></li>
|
||||
<li><a class="reference" href="#where-can-i-find-example-programs-using-the-new-wx-syntax" id="id9" name="id9">Where can I find example programs using the new wx syntax?</a></li>
|
||||
</ul>
|
||||
</div>
|
||||
<div class="section" id="introduction">
|
||||
<h1><a class="toc-backref" href="#id1" name="introduction">Introduction</a></h1>
|
||||
<p>Big things sometimes come in small packages. This is certainly true
|
||||
of the new wx package, which is being introduced in wxPython 2.4.1 as
|
||||
a way to allow the "wx" prefix to be dropped from the names of all
|
||||
wxPython classes, functions, and constants. This document should
|
||||
answer all the questions you might have concerning the new wx package.
|
||||
If not, feel free to contact the author. I hope you like the new wx
|
||||
package as much as I do.</p>
|
||||
</div>
|
||||
<div class="section" id="why-change-anything">
|
||||
<h1><a class="toc-backref" href="#id2" name="why-change-anything">Why change anything?</a></h1>
|
||||
<p>This change is being made for a couple of reasons. The first reason
|
||||
is to discourage the use of <tt class="literal"><span class="pre">import</span> <span class="pre">*</span></tt>, which is a dangerous
|
||||
technique that can create name conflicts and bloated namespaces.</p>
|
||||
<p>The second reason is to remove what some perceive to be a "wart." For
|
||||
example, the following code is rather ugly in that the "wx" prefix on
|
||||
the wxFrame class name is no longer useful when you're using the wx
|
||||
module prefix:</p>
|
||||
<pre class="literal-block">
|
||||
from wxPython import wx
|
||||
|
||||
class Frame(wx.wxFrame)
|
||||
</pre>
|
||||
<p>The new wx package allows you to write code like this, instead:</p>
|
||||
<pre class="literal-block">
|
||||
import wx
|
||||
|
||||
class Frame(wx.Frame)
|
||||
</pre>
|
||||
<p>The third reason is that the wxWindows project intends to do the same
|
||||
thing (implement a new wx namespace and drop the "wx" prefix) and we
|
||||
want wxPython to lead the way.</p>
|
||||
</div>
|
||||
<div class="section" id="what-does-the-new-wx-package-do">
|
||||
<h1><a class="toc-backref" href="#id3" name="what-does-the-new-wx-package-do">What does the new wx package do?</a></h1>
|
||||
<p>As a way of getting to this new syntax as quickly as possible, the
|
||||
code in this new wx package was created. What it does is alter the
|
||||
existing wx namespace dynamically. By making the changes on-the-fly
|
||||
at runtime, we can try out the new syntax before any permanent changes
|
||||
are made to the underlying class library. The downside of making
|
||||
these changes at runtime is that there is a slight delay when you
|
||||
<tt class="literal"><span class="pre">import</span> <span class="pre">wx</span></tt>; the upside is that you can start using the new syntax
|
||||
now.</p>
|
||||
</div>
|
||||
<div class="section" id="will-any-of-this-effect-my-existing-code">
|
||||
<h1><a class="toc-backref" href="#id4" name="will-any-of-this-effect-my-existing-code">Will any of this effect my existing code?</a></h1>
|
||||
<p>No. Your existing code will continue to work and be supported for
|
||||
some time. It will be up to you to decide when to switch to the new
|
||||
syntax. But all new documentation and code examples will use the new
|
||||
syntax. So don't wait too long. You wouldn't want anyone calling you
|
||||
old-fashioned, would you?</p>
|
||||
</div>
|
||||
<div class="section" id="how-does-the-new-wx-package-work">
|
||||
<h1><a class="toc-backref" href="#id5" name="how-does-the-new-wx-package-work">How does the new wx package work?</a></h1>
|
||||
<p>It's pretty simple, and pretty clever. The wx directory contains an
|
||||
<tt class="literal"><span class="pre">__init__.py</span></tt> file, making it a Python package. (In contrast, the
|
||||
old wxPython.wx module is a module, not a package.) When you <tt class="literal"><span class="pre">import</span>
|
||||
<span class="pre">wx</span></tt> the code in the <tt class="literal"><span class="pre">__init__.py</span></tt> file is executed, and that's
|
||||
where all the magic takes place. Let's take a look at the code inside
|
||||
the <tt class="literal"><span class="pre">__init__.py</span></tt> file:</p>
|
||||
<pre class="literal-block">
|
||||
"""wx package
|
||||
|
||||
Provides a way to drop the wx prefix from wxPython objects."""
|
||||
|
||||
__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
|
||||
__cvsid__ = "$Id$"
|
||||
__revision__ = "$Revision$"[11:-2]
|
||||
|
||||
from wxPython import wx
|
||||
|
||||
import types
|
||||
|
||||
d_new = globals()
|
||||
d_old = wx.__dict__
|
||||
|
||||
for old, obj in d_old.items():
|
||||
if type(obj) is types.ModuleType or old.startswith('_'):
|
||||
# Skip modules and private names.
|
||||
continue
|
||||
new = old
|
||||
if old.startswith('EVT_'):
|
||||
# Leave name unmodified; add to the new wx namespace.
|
||||
d_new[new] = obj
|
||||
elif old.startswith('wxEVT_'):
|
||||
# Leave name unmodified; add to the new wx namespace.
|
||||
d_new[new] = obj
|
||||
else:
|
||||
if old.startswith('wx'):
|
||||
# Remove the 'wx' prefix.
|
||||
new = old[2:]
|
||||
# Add to the new wx package namespace.
|
||||
d_new[new] = obj
|
||||
|
||||
del d_new
|
||||
del d_old
|
||||
del new
|
||||
del obj
|
||||
del old
|
||||
del types
|
||||
|
||||
del wx
|
||||
|
||||
</pre>
|
||||
<p>Namespaces in Python are implemented as dictionaries. The dictionary
|
||||
used to create the wx package's namespace is accessible using the
|
||||
<tt class="literal"><span class="pre">globals()</span></tt> function. The dictionary used to create the old
|
||||
wxPython.wx module's namespace is <tt class="literal"><span class="pre">wx.__dict__</span></tt>. Once we have these
|
||||
two dictionaries, it's a simple matter of iterating through one,
|
||||
changing the names, adding the renamed object to the other dictionary,
|
||||
and cleaning up a few local variables and imported modules. Voila!</p>
|
||||
</div>
|
||||
<div class="section" id="what-about-all-the-other-modules-like-grid-html-and-stc">
|
||||
<h1><a class="toc-backref" href="#id6" name="what-about-all-the-other-modules-like-grid-html-and-stc">What about all the other modules, like grid, html, and stc?</a></h1>
|
||||
<p>There's more to wxPython than just the wx namespace. And we've got
|
||||
those extra modules covered as well. For each of those modules (as
|
||||
well as the lib package) we've got matching modules in the new wx
|
||||
package. Let's take a look at a few of them.</p>
|
||||
<p>Here is <tt class="literal"><span class="pre">html.py</span></tt>:</p>
|
||||
<pre class="literal-block">
|
||||
"""Provides a way to drop the wx prefix from wxPython objects."""
|
||||
|
||||
__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
|
||||
__cvsid__ = "$Id$"
|
||||
__revision__ = "$Revision$"[11:-2]
|
||||
|
||||
import wx
|
||||
from wx import prefix
|
||||
|
||||
from wxPython import html
|
||||
prefix.rename(d_new=globals(), d_old=html.__dict__)
|
||||
del html
|
||||
|
||||
del prefix
|
||||
del wx
|
||||
|
||||
</pre>
|
||||
<p>And here is <tt class="literal"><span class="pre">lib/dialogs.py</span></tt>:</p>
|
||||
<pre class="literal-block">
|
||||
"""Provides a way to drop the wx prefix from wxPython objects."""
|
||||
|
||||
__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
|
||||
__cvsid__ = "$Id$"
|
||||
__revision__ = "$Revision$"[11:-2]
|
||||
|
||||
import wx
|
||||
from wx import prefix
|
||||
|
||||
from wxPython.lib import dialogs
|
||||
prefix.rename(d_new=globals(), d_old=dialogs.__dict__)
|
||||
del dialogs
|
||||
|
||||
del prefix
|
||||
del wx
|
||||
|
||||
</pre>
|
||||
<p>As you can see, they both rely on the <tt class="literal"><span class="pre">prefix.rename()</span></tt> function
|
||||
defined in <tt class="literal"><span class="pre">prefix.py</span></tt>:</p>
|
||||
<pre class="literal-block">
|
||||
"""Renaming utility.
|
||||
|
||||
Provides a way to drop the wx prefix from wxPython objects."""
|
||||
|
||||
__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
|
||||
__cvsid__ = "$Id$"
|
||||
__revision__ = "$Revision$"[11:-2]
|
||||
|
||||
import types
|
||||
|
||||
def rename(d_new, d_old):
|
||||
for old, obj in d_old.items():
|
||||
if type(obj) is types.ModuleType or old.startswith('_'):
|
||||
# Skip modules and private names.
|
||||
continue
|
||||
## mod = d_old['__name__']
|
||||
## if hasattr(obj, '__module__') and not obj.__module__.startswith(mod):
|
||||
## # Skip objects imported from other modules, except those
|
||||
## # related to the current module, such as stc_.
|
||||
## continue
|
||||
new = old
|
||||
if old.startswith('EVT_') or old.startswith('wxEVT_'):
|
||||
# Leave these names unmodified.
|
||||
pass
|
||||
elif old.startswith('wx'):
|
||||
new = old[2:]
|
||||
if new:
|
||||
d_new[new] = d_old[old]
|
||||
|
||||
</pre>
|
||||
<p>Again, the technique is very similar to the one used by the wx
|
||||
package.</p>
|
||||
</div>
|
||||
<div class="section" id="how-do-i-use-this-new-wx-package">
|
||||
<h1><a class="toc-backref" href="#id7" name="how-do-i-use-this-new-wx-package">How do I use this new wx package?</a></h1>
|
||||
<p>The wx package is automatically created when you install wxPython
|
||||
version 2.4.1 or higher. So all you have to do is:</p>
|
||||
<pre class="literal-block">
|
||||
import wx
|
||||
</pre>
|
||||
</div>
|
||||
<div class="section" id="what-are-the-issues-with-converting-old-code-to-use-the-new-wx-package">
|
||||
<h1><a class="toc-backref" href="#id8" name="what-are-the-issues-with-converting-old-code-to-use-the-new-wx-package">What are the issues with converting old code to use the new wx package?</a></h1>
|
||||
<p>Obviously, you need to change your import statements from:</p>
|
||||
<pre class="literal-block">
|
||||
from wxPython import wx
|
||||
</pre>
|
||||
<p>or:</p>
|
||||
<pre class="literal-block">
|
||||
from wxPython.wx import *
|
||||
</pre>
|
||||
<p>to:</p>
|
||||
<pre class="literal-block">
|
||||
import wx
|
||||
</pre>
|
||||
<p>Then you need to refer to wx attributes without a "wx" prefix, such
|
||||
as:</p>
|
||||
<pre class="literal-block">
|
||||
class MyFrame(wx.Frame):
|
||||
</pre>
|
||||
<p>In most cases, existing code can be modified with a simple search and
|
||||
replace.</p>
|
||||
<p>One extra issue you might run into when converting existing code is
|
||||
that the wx.__version__ attribute is no longer available, since the
|
||||
new wx namespace doesn't include any private attributes from the old
|
||||
wxPython.wx namespace. The solution is to use the wx.VERSION_STRING
|
||||
attribute, which was introduced in wxPython 2.4.1.</p>
|
||||
</div>
|
||||
<div class="section" id="where-can-i-find-example-programs-using-the-new-wx-syntax">
|
||||
<h1><a class="toc-backref" href="#id9" name="where-can-i-find-example-programs-using-the-new-wx-syntax">Where can I find example programs using the new wx syntax?</a></h1>
|
||||
<p>Example programs are included in the wxPython/samples/wx_examples
|
||||
directory, and are documented in the <a class="reference" href="wxPythonExamples.html">wxPythonExamples</a> documentation
|
||||
file. Also, all the code in the py package uses the new wx syntax.
|
||||
You can learn more about these in the <a class="reference" href="PyManual.html">PyManual</a>.</p>
|
||||
</div>
|
||||
</div>
|
||||
<hr class="footer"/>
|
||||
<div class="footer">
|
||||
<a class="reference" href="wxPackage.txt">View document source</a>.
|
||||
Generated on: 2003-06-04 18:07 UTC.
|
||||
Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
|
||||
</div>
|
||||
</body>
|
||||
</html>
|
||||
@@ -9,48 +9,48 @@ in Python. This is not part of the demo framework.
|
||||
"""
|
||||
|
||||
|
||||
from wxPython.wx import *
|
||||
import wx
|
||||
import time
|
||||
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
class MyFrame(wxFrame):
|
||||
class MyFrame(wx.Frame):
|
||||
|
||||
def __init__(self, parent, id, title):
|
||||
wxFrame.__init__(self, parent, id, title,
|
||||
wxPoint(100, 100), wxSize(160, 150))
|
||||
wx.Frame.__init__(self, parent, id, title,
|
||||
wx.Point(100, 100), wx.Size(160, 150))
|
||||
|
||||
EVT_SIZE(self, self.OnSize)
|
||||
EVT_MOVE(self, self.OnMove)
|
||||
EVT_CLOSE(self, self.OnCloseWindow)
|
||||
EVT_IDLE(self, self.OnIdle)
|
||||
wx.EVT_SIZE(self, self.OnSize)
|
||||
wx.EVT_MOVE(self, self.OnMove)
|
||||
wx.EVT_CLOSE(self, self.OnCloseWindow)
|
||||
wx.EVT_IDLE(self, self.OnIdle)
|
||||
|
||||
self.count = 0
|
||||
|
||||
panel = wxPanel(self, -1)
|
||||
wxStaticText(panel, -1, "Size:",
|
||||
wxDLG_PNT(panel, wxPoint(4, 4)), wxDefaultSize)
|
||||
wxStaticText(panel, -1, "Pos:",
|
||||
wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
|
||||
panel = wx.Panel(self, -1)
|
||||
wx.StaticText(panel, -1, "Size:",
|
||||
wx.DLG_PNT(panel, wx.Point(4, 4)), wx.DefaultSize)
|
||||
wx.StaticText(panel, -1, "Pos:",
|
||||
wx.DLG_PNT(panel, wx.Point(4, 16)), wx.DefaultSize)
|
||||
|
||||
wxStaticText(panel, -1, "Idle:",
|
||||
wxDLG_PNT(panel, wxPoint(4, 28)), wxDefaultSize)
|
||||
wx.StaticText(panel, -1, "Idle:",
|
||||
wx.DLG_PNT(panel, wx.Point(4, 28)), wx.DefaultSize)
|
||||
|
||||
self.sizeCtrl = wxTextCtrl(panel, -1, "",
|
||||
wxDLG_PNT(panel, wxPoint(24, 4)),
|
||||
wxDLG_SZE(panel, wxSize(36, -1)),
|
||||
wxTE_READONLY)
|
||||
self.sizeCtrl = wx.TextCtrl(panel, -1, "",
|
||||
wx.DLG_PNT(panel, wx.Point(24, 4)),
|
||||
wx.DLG_SZE(panel, wx.Size(36, -1)),
|
||||
wx.TE_READONLY)
|
||||
|
||||
self.posCtrl = wxTextCtrl(panel, -1, "",
|
||||
wxDLG_PNT(panel, wxPoint(24, 16)),
|
||||
wxDLG_SZE(panel, wxSize(36, -1)),
|
||||
wxTE_READONLY)
|
||||
self.posCtrl = wx.TextCtrl(panel, -1, "",
|
||||
wx.DLG_PNT(panel, wx.Point(24, 16)),
|
||||
wx.DLG_SZE(panel, wx.Size(36, -1)),
|
||||
wx.TE_READONLY)
|
||||
|
||||
self.idleCtrl = wxTextCtrl(panel, -1, "",
|
||||
wxDLG_PNT(panel, wxPoint(24, 28)),
|
||||
wxDLG_SZE(panel, wxSize(36, -1)),
|
||||
wxTE_READONLY)
|
||||
self.idleCtrl = wx.TextCtrl(panel, -1, "",
|
||||
wx.DLG_PNT(panel, wx.Point(24, 28)),
|
||||
wx.DLG_SZE(panel, wx.Size(36, -1)),
|
||||
wx.TE_READONLY)
|
||||
|
||||
|
||||
def OnCloseWindow(self, event):
|
||||
@@ -74,7 +74,7 @@ class MyFrame(wxFrame):
|
||||
|
||||
#---------------------------------------------------------------------------
|
||||
|
||||
class MyApp(wxApp):
|
||||
class MyApp(wx.App):
|
||||
def MainLoop(self):
|
||||
# This outer loop determines when to exit the application, for
|
||||
# this example we let the main frame reset this flag when it
|
||||
|
||||
@@ -19,7 +19,7 @@ on the command line.
|
||||
|
||||
|
||||
import sys, os
|
||||
from wxPython.wx import *
|
||||
import wx
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
@@ -27,34 +27,34 @@ class Log:
|
||||
def WriteText(self, text):
|
||||
if text[-1:] == '\n':
|
||||
text = text[:-1]
|
||||
wxLogMessage(text)
|
||||
wx.LogMessage(text)
|
||||
write = WriteText
|
||||
|
||||
|
||||
class RunDemoApp(wxApp):
|
||||
class RunDemoApp(wx.App):
|
||||
def __init__(self, name, module):
|
||||
self.name = name
|
||||
self.demoModule = module
|
||||
wxApp.__init__(self, 0) ##wxPlatform == "__WXMAC__")
|
||||
wx.App.__init__(self, 0)
|
||||
|
||||
|
||||
def OnInit(self):
|
||||
wxInitAllImageHandlers()
|
||||
wxLog_SetActiveTarget(wxLogStderr())
|
||||
wx.InitAllImageHandlers()
|
||||
wx.Log_SetActiveTarget(wx.LogStderr())
|
||||
|
||||
#self.SetAssertMode(wxPYAPP_ASSERT_DIALOG)
|
||||
#self.SetAssertMode(wx.PYAPP_ASSERT_DIALOG)
|
||||
|
||||
frame = wxFrame(None, -1, "RunDemo: " + self.name, pos=(50,50), size=(0,0),
|
||||
style=wxNO_FULL_REPAINT_ON_RESIZE|wxDEFAULT_FRAME_STYLE)
|
||||
frame = wx.Frame(None, -1, "RunDemo: " + self.name, pos=(50,50), size=(0,0),
|
||||
style=wx.NO_FULL_REPAINT_ON_RESIZE|wx.DEFAULT_FRAME_STYLE)
|
||||
frame.CreateStatusBar()
|
||||
menuBar = wxMenuBar()
|
||||
menu = wxMenu()
|
||||
menuBar = wx.MenuBar()
|
||||
menu = wx.Menu()
|
||||
menu.Append(101, "E&xit\tAlt-X", "Exit demo")
|
||||
EVT_MENU(self, 101, self.OnButton)
|
||||
wx.EVT_MENU(self, 101, self.OnButton)
|
||||
menuBar.Append(menu, "&File")
|
||||
frame.SetMenuBar(menuBar)
|
||||
frame.Show(True)
|
||||
EVT_CLOSE(frame, self.OnCloseFrame)
|
||||
wx.EVT_CLOSE(frame, self.OnCloseFrame)
|
||||
|
||||
win = self.demoModule.runTest(frame, frame, Log())
|
||||
|
||||
@@ -70,9 +70,9 @@ class RunDemoApp(wxApp):
|
||||
# otherwise the demo made its own frame, so just put a
|
||||
# button in this one
|
||||
if hasattr(frame, 'otherWin'):
|
||||
b = wxButton(frame, -1, " Exit ")
|
||||
b = wx.Button(frame, -1, " Exit ")
|
||||
frame.SetSize((200, 100))
|
||||
EVT_BUTTON(frame, b.GetId(), self.OnButton)
|
||||
wx.EVT_BUTTON(frame, b.GetId(), self.OnButton)
|
||||
else:
|
||||
# It was probably a dialog or something that is already
|
||||
# gone, so we're done.
|
||||
@@ -81,8 +81,8 @@ class RunDemoApp(wxApp):
|
||||
|
||||
self.SetTopWindow(frame)
|
||||
self.frame = frame
|
||||
#wxLog_SetActiveTarget(wxLogStderr())
|
||||
#wxLog_SetTraceMask(wxTraceMessages)
|
||||
#wx.Log_SetActiveTarget(wx.LogStderr())
|
||||
#wx.Log_SetTraceMask(wx.TraceMessages)
|
||||
return True
|
||||
|
||||
|
||||
|
||||
@@ -5,38 +5,38 @@
|
||||
# structure of any wxPython application.
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
from wxPython.wx import *
|
||||
import wx
|
||||
|
||||
class MyFrame(wxFrame):
|
||||
class MyFrame(wx.Frame):
|
||||
"""
|
||||
This is MyFrame. It just shows a few controls on a wxPanel,
|
||||
and has a simple menu.
|
||||
"""
|
||||
def __init__(self, parent, title):
|
||||
wxFrame.__init__(self, parent, -1, title, size=(350, 200))
|
||||
wx.Frame.__init__(self, parent, -1, title, size=(350, 200))
|
||||
|
||||
menuBar = wxMenuBar()
|
||||
menu = wxMenu()
|
||||
menuBar = wx.MenuBar()
|
||||
menu = wx.Menu()
|
||||
menu.Append(101, "E&xit\tAlt-X", "Exit demo")
|
||||
EVT_MENU(self, 101, self.OnButton)
|
||||
wx.EVT_MENU(self, 101, self.OnButton)
|
||||
menuBar.Append(menu, "&File")
|
||||
self.SetMenuBar(menuBar)
|
||||
|
||||
panel = wxPanel(self, -1)
|
||||
text = wxStaticText(panel, -1, "Hello World!")
|
||||
text.SetFont(wxFont(12, wxSWISS, wxNORMAL, wxBOLD))
|
||||
panel = wx.Panel(self, -1)
|
||||
text = wx.StaticText(panel, -1, "Hello World!")
|
||||
text.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
|
||||
text.SetSize(text.GetBestSize())
|
||||
btn = wxButton(panel, -1, "Close")
|
||||
btn = wx.Button(panel, -1, "Close")
|
||||
btn.SetDefault()
|
||||
|
||||
sizer = wxBoxSizer(wxVERTICAL)
|
||||
sizer.Add(text, 0, wxALL, 10)
|
||||
sizer.Add(btn, 0, wxALL, 10)
|
||||
sizer = wx.BoxSizer(wx.VERTICAL)
|
||||
sizer.Add(text, 0, wx.ALL, 10)
|
||||
sizer.Add(btn, 0, wx.ALL, 10)
|
||||
panel.SetSizer(sizer)
|
||||
panel.SetAutoLayout(True)
|
||||
panel.Layout()
|
||||
|
||||
EVT_BUTTON(self, btn.GetId(), self.OnButton)
|
||||
wx.EVT_BUTTON(self, btn.GetId(), self.OnButton)
|
||||
|
||||
|
||||
def OnButton(self, evt):
|
||||
@@ -44,7 +44,8 @@ class MyFrame(wxFrame):
|
||||
print "OnButton"
|
||||
self.Close()
|
||||
|
||||
app = wxPySimpleApp()
|
||||
|
||||
app = wx.PySimpleApp()
|
||||
frame = MyFrame(None, "Simple wxPython App")
|
||||
frame.Show(True)
|
||||
app.MainLoop()
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
|
||||
from wxPython.wx import *
|
||||
import wx
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class TestPanel(wxPanel):
|
||||
class TestPanel(wx.Panel):
|
||||
def __init__(self, parent, log):
|
||||
self.log = log
|
||||
wxPanel.__init__(self, parent, -1)
|
||||
wx.Panel.__init__(self, parent, -1)
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
||||
@@ -11,6 +11,7 @@ buttonDefs = {
|
||||
819 : ('GridEnterHandler',' Remapping keys to behave differently '),
|
||||
820 : ('GridCustEditor', ' Shows how to create a custom Cell Editor '),
|
||||
821 : ('GridDragable', ' A wxGrid with dragable rows and columns '),
|
||||
822 : ('GridDragAndDrop', 'Shows how to make a grid a drop target for files'),
|
||||
}
|
||||
|
||||
|
||||
@@ -26,7 +27,7 @@ class ButtonPanel(wxPanel):
|
||||
for k in keys:
|
||||
text = buttonDefs[k][1]
|
||||
btn = wxButton(self, k, text)
|
||||
box.Add(btn, 0, wxALIGN_CENTER|wxALL, 15)
|
||||
box.Add(btn, 0, wxALIGN_CENTER|wxALL, 10)
|
||||
EVT_BUTTON(self, k, self.OnButton)
|
||||
|
||||
self.SetAutoLayout(True)
|
||||
@@ -94,9 +95,6 @@ changes how the ENTER key works, moving the current cell left to right
|
||||
and wrapping around to the next row when needed.
|
||||
</ol>
|
||||
<p>
|
||||
You can also look at the <a href="data/grid.i">SWIG interface
|
||||
file</a> used to generate the grid module for a lot more clues as to
|
||||
how things work.
|
||||
|
||||
"""
|
||||
|
||||
|
||||
Reference in New Issue
Block a user