wxPython is brought to you by Robin Dunn and
-Total Control Software, Copyright (c) 1997-2002.
Please see license.txt for licensing information.
- wxPython is a GUI toolkit for the Python 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 wxWindows cross
+platform GUI library, which is written in C++.
- 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.
+ Like Python and wxWindows, wxPython is Open Source 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.
- wxPython is a cross-platform 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 simple, easy to write and easy to
+understand.
- 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.
+ This demo 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.
- 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.
-
-
-
-
- The wxPython extension module attempts to mirror the class heiarchy
- of wxWindows as closely as possible. This means that there is a
- wxFrame class in wxPython that looks, smells, tastes and acts almost
- the same as the wxFrame class in the C++ version. Unfortunately,
- because of differences in the languages, wxPython doesn't match
- wxWindows exactly, but the differences should be easy to absorb
- because they are natural to Python. For example, some methods that
- return multiple values via argument pointers in C++ will return a
- tuple of values in Python.
-
-
-
- There is still much to be done for wxPython, many classes still need
- to be mirrored. Also, wxWindows is still somewhat of a moving target
- so it is a bit of an effort just keeping wxPython up to date. On the
- other hand, there are enough of the core classes completed that
- useful applications can be written.
-
-
-
- wxPython is close enough to the C++ version that the majority of
- the wxPython documentation is actually just notes attached to the C++
- documents that describe the places where wxPython is different. There
- is also a series of sample programs included, and a series of
- documentation pages that assist the programmer in getting started
- with wxPython.
-
- """
+"""
#----------------------------------------------------------------------------
diff --git a/wxPython/demo/NewNamespace.py b/wxPython/demo/NewNamespace.py
index 5533bd03c0..07ebc8e50e 100644
--- a/wxPython/demo/NewNamespace.py
+++ b/wxPython/demo/NewNamespace.py
@@ -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)
diff --git a/wxPython/demo/data/wxPackage.html b/wxPython/demo/data/wxPackage.html
new file mode 100644
index 0000000000..5b2fb06588
--- /dev/null
+++ b/wxPython/demo/data/wxPackage.html
@@ -0,0 +1,290 @@
+
+
+
+ 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. This change is being made for a couple of reasons. The first reason
+is to discourage the use of import *, which is a dangerous
+technique that can create name conflicts and bloated namespaces. 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: The new wx package allows you to write code like this, instead: 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. 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
+import wx; the upside is that you can start using the new syntax
+now. 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? It's pretty simple, and pretty clever. The wx directory contains an
+__init__.py file, making it a Python package. (In contrast, the
+old wxPython.wx module is a module, not a package.) When you import
+wx the code in the __init__.py file is executed, and that's
+where all the magic takes place. Let's take a look at the code inside
+the __init__.py file: Namespaces in Python are implemented as dictionaries. The dictionary
+used to create the wx package's namespace is accessible using the
+globals() function. The dictionary used to create the old
+wxPython.wx module's namespace is wx.__dict__. 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! 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. Here is html.py: And here is lib/dialogs.py: As you can see, they both rely on the prefix.rename() function
+defined in prefix.py: Again, the technique is very similar to the one used by the wx
+package. The wx package is automatically created when you install wxPython
+version 2.4.1 or higher. So all you have to do is: Obviously, you need to change your import statements from: or: to: Then you need to refer to wx attributes without a "wx" prefix, such
+as: In most cases, existing code can be modified with a simple search and
+replace. 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. Example programs are included in the wxPython/samples/wx_examples
+directory, and are documented in the wxPythonExamples documentation
+file. Also, all the code in the py package uses the new wx syntax.
+You can learn more about these in the PyManual.
-You can also look at the SWIG interface
-file used to generate the grid module for a lot more clues as to
-how things work.
"""
Python
+wxPython
- Python is an interpreted, interactive, object-oriented programming
- language often compared to Tcl, Perl, Scheme, or Java.
+wxWindows
+wxPython
-
- wxPython is a Python extension module that encapsulates the wxWindows
- GUI classes. Currently it is only available for the Win32 and GTK
- ports of wxWindows, but as soon as the other ports are brought up to
- the same level as Win32 and GTK, it should be fairly trivial to
- enable wxPython to be used with the new GUI.
-
- The wxPython wx Package
+Or, how to survive the new wx namespace changes.
+
+
+Author:
+Patrick K. O'Brien Contact:
+pobrien@orbtech.com Organization:
+Orbtech Date:
+2003-05-08 Revision:
+1.1.2.4
+
+Introduction
+Why change anything?
+
+from wxPython import wx
+
+class Frame(wx.wxFrame)
+
+
+import wx
+
+class Frame(wx.Frame)
+
+What does the new wx package do?
+Will any of this effect my existing code?
+How does the new wx package work?
+
+"""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
+
+
+What about all the other modules, like grid, html, and stc?
+
+"""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
+
+
+
+"""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
+
+
+
+"""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]
+
+
+How do I use this new wx package?
+
+import wx
+
+What are the issues with converting old code to use the new wx package?
+
+from wxPython import wx
+
+
+from wxPython.wx import *
+
+
+import wx
+
+
+class MyFrame(wx.Frame):
+
+Where can I find example programs using the new wx syntax?
+
+
+
+
diff --git a/wxPython/demo/demoMainLoop.py b/wxPython/demo/demoMainLoop.py
index 3d66c2ae4c..9d707a6978 100755
--- a/wxPython/demo/demoMainLoop.py
+++ b/wxPython/demo/demoMainLoop.py
@@ -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
diff --git a/wxPython/demo/run.py b/wxPython/demo/run.py
index 24ac322b5b..912fb4edbc 100755
--- a/wxPython/demo/run.py
+++ b/wxPython/demo/run.py
@@ -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
diff --git a/wxPython/demo/simple.py b/wxPython/demo/simple.py
index 6b28148228..169313ce30 100644
--- a/wxPython/demo/simple.py
+++ b/wxPython/demo/simple.py
@@ -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()
diff --git a/wxPython/demo/template.py b/wxPython/demo/template.py
index 9be55905b9..86e70c1279 100644
--- a/wxPython/demo/template.py
+++ b/wxPython/demo/template.py
@@ -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)
#----------------------------------------------------------------------
diff --git a/wxPython/demo/wxGrid.py b/wxPython/demo/wxGrid.py
index 365e0125e6..676be13eb5 100644
--- a/wxPython/demo/wxGrid.py
+++ b/wxPython/demo/wxGrid.py
@@ -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.