Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Converted the main demo framework files to the new namespace, (none of

Browse Source 
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
2003-06-05 23:18:16 +00:00
parent 0e8922d54e
commit 46ddee38b0
10 changed files with 614 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

311
wxPython/demo/Main.py
View File

@@ -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,76 +741,36 @@ def main():
overview = """<html><body>
<h2>Python</h2>
<h2>wxPython</h2>
Python is an interpreted, interactive, object-oriented programming
language often compared to Tcl, Perl, Scheme, or Java.
<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> 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>
<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.
<h2>wxWindows</h2>
<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.
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>
<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.
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>
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>
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.
"""
"""
#----------------------------------------------------------------------------