wxPython/demo/Main.py

   1 #!/bin/env python
   2 #----------------------------------------------------------------------------
   3 # Name:         Main.py
   4 # Purpose:      Testing lots of stuff, controls, window types, etc.
   5 #
   6 # Author:       Robin Dunn
   7 #
   8 # Created:      A long time ago, in a galaxy far, far away...
   9 # RCS-ID:       $Id$
  10 # Copyright:    (c) 1999 by Total Control Software
  11 # Licence:      wxWindows license
  12 #----------------------------------------------------------------------------
  13
  14 import sys, os
  15 from   wxPython.wx import *
  16 from   wxPython.lib.splashscreen import SplashScreen
  17 from   wxPython.html import wxHtmlWindow
  18
  19 #---------------------------------------------------------------------------
  20
  21
  22 _treeList = [
  23     ('New since last release', ['wxProcess',
  24                                 ]),
  25
  26     ('Managed Windows', ['wxFrame', 'wxDialog', 'wxMiniFrame']),
  27
  28     ('Non-Managed Windows', ['wxGrid', 'wxSashWindow',
  29                              'wxScrolledWindow', 'wxSplitterWindow',
  30                              'wxStatusBar', 'wxNotebook',
  31                              'wxHtmlWindow',
  32                              'wxStyledTextCtrl_1', 'wxStyledTextCtrl_2',]),
  33
  34     ('Common Dialogs', ['wxColourDialog', 'wxDirDialog', 'wxFileDialog',
  35                         'wxSingleChoiceDialog', 'wxTextEntryDialog',
  36                         'wxFontDialog', 'wxPageSetupDialog', 'wxPrintDialog',
  37                         'wxMessageDialog', 'wxProgressDialog']),
  38
  39     ('Controls', ['wxButton', 'wxCheckBox', 'wxCheckListBox', 'wxChoice',
  40                   'wxComboBox', 'wxGauge', 'wxListBox', 'wxListCtrl', 'wxTextCtrl',
  41                   'wxTreeCtrl', 'wxSpinButton', 'wxSpinCtrl', 'wxStaticText',
  42                   'wxStaticBitmap', 'wxRadioBox', 'wxSlider', 'wxToolBar',
  43                   'wxCalendarCtrl',
  44                   ]),
  45
  46     ('Window Layout', ['wxLayoutConstraints', 'Sizers', ]),
  47
  48     ('Miscellaneous', [ 'DragAndDrop', 'CustomDragAndDrop', 'FontEnumerator',
  49                         'wxTimer', 'wxValidator', 'wxGLCanvas', 'DialogUnits',
  50                         'wxImage', 'wxMask', 'PrintFramework', 'wxOGL',
  51                         'PythonEvents', 'Threads',
  52                         'ActiveXWrapper_Acrobat', 'ActiveXWrapper_IE',
  53                         'wxDragImage',
  54                         ]),
  55
  56     ('wxPython Library', ['Layoutf', 'wxScrolledMessageDialog',
  57                           'wxMultipleChoiceDialog', 'wxPlotCanvas', 'wxFloatBar',
  58                           'PyShell', 'wxCalendar', 'wxMVCTree', 'wxVTKRenderWindow',
  59                           'FileBrowseButton', 'GenericButtons', 'wxEditor',
  60                           'PyShellWindow',
  61                           ]),
  62
  63     ('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
  64
  65     ]
  66
  67 #---------------------------------------------------------------------------
  68
  69 class wxPythonDemo(wxFrame):
  70
  71     def __init__(self, parent, id, title):
  72         wxFrame.__init__(self, parent, -1, title, size = (800, 600),
  73                          style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
  74
  75         self.cwd = os.getcwd()
  76         self.curOverview = ""
  77
  78         if wxPlatform == '__WXMSW__':
  79             icon = wxIcon('bitmaps/mondrian.ico', wxBITMAP_TYPE_ICO)
  80             self.SetIcon(icon)
  81
  82             # setup a taskbar icon, and catch some events from it
  83             self.tbicon = wxTaskBarIcon()
  84             self.tbicon.SetIcon(icon, "wxPython Demo")
  85             EVT_TASKBAR_LEFT_DCLICK(self.tbicon, self.OnTaskBarActivate)
  86             EVT_TASKBAR_RIGHT_UP(self.tbicon, self.OnTaskBarMenu)
  87             EVT_MENU(self.tbicon, self.TBMENU_RESTORE, self.OnTaskBarActivate)
  88             EVT_MENU(self.tbicon, self.TBMENU_CLOSE, self.OnTaskBarClose)
  89
  90
  91         self.otherWin = None
  92         EVT_IDLE(self, self.OnIdle)
  93         EVT_CLOSE(self, self.OnCloseWindow)
  94
  95         self.Centre(wxBOTH)
  96         self.CreateStatusBar(1, wxST_SIZEGRIP)
  97
  98         splitter = wxSplitterWindow(self, -1, style=wxNO_3D|wxSP_3D)
  99         splitter2 = wxSplitterWindow(splitter, -1, style=wxNO_3D|wxSP_3D)
 100
 101
 102         # Prevent TreeCtrl from displaying all items after destruction
 103         self.dying = false
 104
 105         # Make a File menu
 106         self.mainmenu = wxMenuBar()
 107         menu = wxMenu()
 108         exitID = wxNewId()
 109         menu.Append(exitID, 'E&xit\tAlt-X', 'Get the heck outta here!')
 110         EVT_MENU(self, exitID, self.OnFileExit)
 111         self.mainmenu.Append(menu, '&File')
 112
 113         # Make a Demo menu
 114         menu = wxMenu()
 115         for item in _treeList:
 116             submenu = wxMenu()
 117             for childItem in item[1]:
 118                 mID = wxNewId()
 119                 submenu.Append(mID, childItem)
 120                 EVT_MENU(self, mID, self.OnDemoMenu)
 121             menu.AppendMenu(wxNewId(), item[0], submenu)
 122         self.mainmenu.Append(menu, '&Demo')
 123
 124
 125         # Make a Help menu
 126         helpID = wxNewId()
 127         menu = wxMenu()
 128         menu.Append(helpID, '&About\tCtrl-H', 'wxPython RULES!!!')
 129         EVT_MENU(self, helpID, self.OnHelpAbout)
 130         self.mainmenu.Append(menu, '&Help')
 131         self.SetMenuBar(self.mainmenu)
 132
 133         # set the menu accellerator table...
 134         aTable = wxAcceleratorTable([(wxACCEL_ALT,  ord('X'), exitID),
 135                                      (wxACCEL_CTRL, ord('H'), helpID)])
 136         self.SetAcceleratorTable(aTable)
 137
 138
 139         # Create a TreeCtrl
 140         tID = wxNewId()
 141         self.treeMap = {}
 142         self.tree = wxTreeCtrl(splitter, tID,
 143                                style=wxTR_HAS_BUTTONS |
 144                                wxTR_EDIT_LABELS |
 145                                wxTR_HAS_VARIABLE_ROW_HEIGHT |
 146                                wxSUNKEN_BORDER)
 147         #self.tree.SetBackgroundColour(wxNamedColour("Pink"))
 148         root = self.tree.AddRoot("Overview")
 149         firstChild = None
 150         for item in _treeList:
 151             child = self.tree.AppendItem(root, item[0])
 152             if not firstChild: firstChild = child
 153             for childItem in item[1]:
 154                 theDemo = self.tree.AppendItem(child, childItem)
 155                 self.treeMap[childItem] = theDemo
 156
 157         self.tree.Expand(root)
 158         self.tree.Expand(firstChild)
 159         EVT_TREE_ITEM_EXPANDED   (self.tree, tID, self.OnItemExpanded)
 160         EVT_TREE_ITEM_COLLAPSED  (self.tree, tID, self.OnItemCollapsed)
 161         EVT_TREE_SEL_CHANGED     (self.tree, tID, self.OnSelChanged)
 162         EVT_LEFT_DOWN            (self.tree,      self.OnTreeLeftDown)
 163
 164         # Create a Notebook
 165         self.nb = wxNotebook(splitter2, -1)
 166
 167         # Set up a wxHtmlWindow on the Overview Notebook page
 168         # we put it in a panel first because there seems to be a
 169         # refresh bug of some sort (wxGTK) when it is directly in
 170         # the notebook...
 171         if 0:  # the old way
 172             self.ovr = wxHtmlWindow(self.nb, -1, size=(400, 400))
 173             self.nb.AddPage(self.ovr, "Overview")
 174
 175         else:  # hopefully I can remove this hacky code soon
 176             panel = wxPanel(self.nb, -1)
 177             self.ovr = wxHtmlWindow(panel, -1, size=(400, 400))
 178             self.nb.AddPage(panel, "Overview")
 179
 180             def OnOvrSize(evt, ovr=self.ovr):
 181                 ovr.SetSize(evt.GetSize())
 182
 183             EVT_SIZE(panel, OnOvrSize)
 184
 185         self.SetOverview("Overview", overview)
 186
 187
 188         # Set up a TextCtrl on the Demo Code Notebook page
 189         self.txt = wxTextCtrl(self.nb, -1,
 190                               style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
 191         self.txt.SetFont(wxFont(9, wxMODERN, wxNORMAL, wxNORMAL, false))
 192         self.nb.AddPage(self.txt, "Demo Code")
 193
 194
 195         # Set up a log on the View Log Notebook page
 196         self.log = wxTextCtrl(splitter2, -1,
 197                               style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
 198         # Set the wxWindows log target to be this textctrl
 199         wxLog_SetActiveTarget(wxLogTextCtrl(self.log))
 200
 201
 202
 203         self.Show(true)
 204
 205         # add the windows to the splitter and split it.
 206         splitter2.SplitHorizontally(self.nb, self.log)
 207         splitter2.SetSashPosition(450, true)
 208         splitter2.SetMinimumPaneSize(20)
 209
 210         splitter.SplitVertically(self.tree, splitter2)
 211         splitter.SetSashPosition(180, true)
 212         splitter.SetMinimumPaneSize(20)
 213
 214
 215         # select initial items
 216         self.nb.SetSelection(0)
 217         self.tree.SelectItem(root)
 218
 219         if len(sys.argv) == 2:
 220             try:
 221                 selectedDemo = self.treeMap[sys.argv[1]]
 222             except:
 223                 selectedDemo = None
 224             if selectedDemo:
 225                 self.tree.SelectItem(selectedDemo)
 226                 self.tree.EnsureVisible(selectedDemo)
 227
 228
 229         wxLogMessage('window handle: %s' % self.GetHandle())
 230
 231
 232     #---------------------------------------------
 233     def WriteText(self, text):
 234         if text[-1:] == '\n':
 235             text = text[:-1]
 236         wxLogMessage(text)
 237
 238
 239     def write(self, txt):
 240         self.WriteText(txt)
 241
 242     #---------------------------------------------
 243     def OnItemExpanded(self, event):
 244         item = event.GetItem()
 245         wxLogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
 246         event.Skip()
 247
 248     #---------------------------------------------
 249     def OnItemCollapsed(self, event):
 250         item = event.GetItem()
 251         wxLogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
 252         event.Skip()
 253
 254     #---------------------------------------------
 255     def OnTreeLeftDown(self, event):
 256         pt = event.GetPosition();
 257         item, flags = self.tree.HitTest(pt)
 258         if item == self.tree.GetSelection():
 259             self.SetOverview(self.tree.GetItemText(item), self.curOverview)
 260         else:
 261             event.Skip()
 262
 263     #---------------------------------------------
 264     def OnSelChanged(self, event):
 265         if self.dying:
 266             return
 267
 268         item = event.GetItem()
 269         itemText = self.tree.GetItemText(item)
 270         self.RunDemo(itemText)
 271
 272
 273     #---------------------------------------------
 274     def RunDemo(self, itemText):
 275         os.chdir(self.cwd)
 276         if self.nb.GetPageCount() == 3:
 277             if self.nb.GetSelection() == 2:
 278                 self.nb.SetSelection(0)
 279             self.nb.DeletePage(2)
 280
 281         if itemText == 'Overview':
 282             self.GetDemoFile('Main.py')
 283             self.SetOverview('Overview', overview)
 284             self.nb.Refresh();
 285             self.window = None
 286
 287         else:
 288             if os.path.exists(itemText + '.py'):
 289                 wxBeginBusyCursor()
 290                 wxLogMessage("Running demo %s.py..." % itemText)
 291                 try:
 292                     self.GetDemoFile(itemText + '.py')
 293                     module = __import__(itemText, globals())
 294                     self.SetOverview(itemText, module.overview)
 295                 finally:
 296                     wxEndBusyCursor()
 297
 298                 # in case runTest is modal, make sure things look right...
 299                 self.nb.Refresh();
 300                 wxYield()
 301
 302                 self.window = module.runTest(self, self.nb, self) ###
 303                 if self.window:
 304                     self.nb.AddPage(self.window, 'Demo')
 305                     wxYield()
 306                     self.nb.SetSelection(2)
 307
 308             else:
 309                 self.ovr.SetPage("")
 310                 self.txt.Clear()
 311                 self.window = None
 312
 313
 314
 315     #---------------------------------------------
 316     # Get the Demo files
 317     def GetDemoFile(self, filename):
 318         self.txt.Clear()
 319         try:
 320             self.txt.SetValue(open(filename).read())
 321         except IOError:
 322             self.txt.WriteText("Cannot open %s file." % filename)
 323
 324         self.txt.SetInsertionPoint(0)
 325         self.txt.ShowPosition(0)
 326
 327     #---------------------------------------------
 328     def SetOverview(self, name, text):
 329         self.curOverview = text
 330         lead = text[:6]
 331         if lead != '<html>' and lead != '<HTML>':
 332             text = string.join(string.split(text, '\n'), '<br>')
 333             #text = '<font size="-1"><pre>' + text + '</pre></font>'
 334         self.ovr.SetPage(text)
 335         self.nb.SetPageText(0, name)
 336
 337     #---------------------------------------------
 338     # Menu methods
 339     def OnFileExit(self, *event):
 340         self.Close()
 341
 342
 343     def OnHelpAbout(self, event):
 344         from About import MyAboutBox
 345         about = MyAboutBox(self)
 346         about.ShowModal()
 347         about.Destroy()
 348
 349
 350     #---------------------------------------------
 351     def OnCloseWindow(self, event):
 352         self.dying = true
 353         self.window = None
 354         self.mainmenu = None
 355         if hasattr(self, "tbicon"):
 356             del self.tbicon
 357         self.Destroy()
 358
 359
 360     #---------------------------------------------
 361     def OnIdle(self, event):
 362         if self.otherWin:
 363             self.otherWin.Raise()
 364             self.window = self.otherWin
 365             self.otherWin = None
 366
 367     #---------------------------------------------
 368     def OnDemoMenu(self, event):
 369         try:
 370             selectedDemo = self.treeMap[self.mainmenu.GetLabel(event.GetId())]
 371         except:
 372             selectedDemo = None
 373         if selectedDemo:
 374             self.tree.SelectItem(selectedDemo)
 375             self.tree.EnsureVisible(selectedDemo)
 376
 377
 378     #---------------------------------------------
 379     def OnTaskBarActivate(self, evt):
 380         if self.IsIconized():
 381             self.Iconize(false)
 382         if not self.IsShown():
 383             self.Show(true)
 384         self.Raise()
 385
 386     #---------------------------------------------
 387
 388     TBMENU_RESTORE = 1000
 389     TBMENU_CLOSE   = 1001
 390
 391     def OnTaskBarMenu(self, evt):
 392         menu = wxMenu()
 393         menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
 394         menu.Append(self.TBMENU_CLOSE,   "Close")
 395         self.tbicon.PopupMenu(menu)
 396         menu.Destroy()
 397
 398     #---------------------------------------------
 399     def OnTaskBarClose(self, evt):
 400         self.Close()
 401
 402         # because of the way wxTaskBarIcon.PopupMenu is implemented we have to
 403         # prod the main idle handler a bit to get the window to actually close
 404         wxGetApp().ProcessIdle()
 405
 406
 407 #---------------------------------------------------------------------------
 408 #---------------------------------------------------------------------------
 409
 410 class MyApp(wxApp):
 411     def OnInit(self):
 412         wxInitAllImageHandlers()
 413
 414         self.splash = SplashScreen(None, bitmapfile='bitmaps/splash.gif',
 415                               duration=4000, callback=self.AfterSplash)
 416         self.splash.Show(true)
 417         wxYield()
 418         return true
 419
 420
 421     def AfterSplash(self):
 422         self.splash.Close(true)
 423         frame = wxPythonDemo(None, -1, "wxPython: (A Demonstration)")
 424         frame.Show(true)
 425         self.SetTopWindow(frame)
 426         self.ShowTip(frame)
 427
 428
 429     def ShowTip(self, frame):
 430         try:
 431             showTipText = open("data/showTips").read()
 432             showTip, index = eval(showTipText)
 433         except IOError:
 434             showTip, index = (1, 0)
 435         #print showTip, index
 436         if showTip:
 437             tp = wxCreateFileTipProvider("data/tips.txt", index)
 438             showTip = wxShowTip(frame, tp)
 439             index = tp.GetCurrentTip()
 440             open("data/showTips", "w").write(str( (showTip, index) ))
 441
 442
 443 #---------------------------------------------------------------------------
 444
 445 def main():
 446     try:
 447         demoPath = os.path.split(__file__)[0]
 448         os.chdir(demoPath)
 449     except:
 450         pass
 451     app = MyApp(0)
 452     app.MainLoop()
 453
 454
 455 #---------------------------------------------------------------------------
 456
 457
 458
 459 overview = """<html><body>
 460  <h2>Python</h2>
 461
 462  Python is an interpreted, interactive, object-oriented programming
 463  language often compared to Tcl, Perl, Scheme, or Java.
 464
 465  <p> Python combines remarkable power with very clear syntax. It has
 466  modules, classes, exceptions, very high level dynamic data types, and
 467  dynamic typing.  There are interfaces to many system calls and
 468  libraries, and new built-in modules are easily written in C or
 469  C++. Python is also usable as an extension language for applications
 470  that need a programmable interface.  <p>
 471
 472  <h2>wxWindows</h2>
 473
 474  wxWindows is a free C++ framework designed to make cross-platform
 475  programming child's play. Well, almost. wxWindows 2 supports Windows
 476  3.1/95/98/NT, Unix with GTK/Motif/Lesstif, with a Mac version
 477  underway. Other ports are under consideration.  <p>
 478
 479  wxWindows is a set of libraries that allows C++ applications to
 480  compile and run on several different types of computers, with minimal
 481  source code changes.  There is one library per supported GUI (such as
 482  Motif, or Windows). As well as providing a common API (Application
 483  Programming Interface) for GUI functionality, it provides
 484  functionality for accessing some commonly-used operating system
 485  facilities, such as copying or deleting files. wxWindows is a
 486  'framework' in the sense that it provides a lot of built-in
 487  functionality, which the application can use or replace as required,
 488  thus saving a great deal of coding effort. Basic data structures such
 489  as strings, linked lists and hash tables are also supported.
 490
 491  <p>
 492  <h2>wxPython</h2>
 493
 494  wxPython is a Python extension module that encapsulates the wxWindows
 495  GUI classes. Currently it is only available for the Win32 and GTK
 496  ports of wxWindows, but as soon as the other ports are brought up to
 497  the same level as Win32 and GTK, it should be fairly trivial to
 498  enable wxPython to be used with the new GUI.
 499
 500  <p>
 501
 502  The wxPython extension module attempts to mirror the class heiarchy
 503  of wxWindows as closely as possible. This means that there is a
 504  wxFrame class in wxPython that looks, smells, tastes and acts almost
 505  the same as the wxFrame class in the C++ version. Unfortunately,
 506  because of differences in the languages, wxPython doesn't match
 507  wxWindows exactly, but the differences should be easy to absorb
 508  because they are natural to Python. For example, some methods that
 509  return multiple values via argument pointers in C++ will return a
 510  tuple of values in Python.
 511
 512  <p>
 513
 514  There is still much to be done for wxPython, many classes still need
 515  to be mirrored. Also, wxWindows is still somewhat of a moving target
 516  so it is a bit of an effort just keeping wxPython up to date. On the
 517  other hand, there are enough of the core classes completed that
 518  useful applications can be written.
 519
 520  <p>
 521
 522  wxPython is close enough to the C++ version that the majority of
 523  the wxPython documentation is actually just notes attached to the C++
 524  documents that describe the places where wxPython is different. There
 525  is also a series of sample programs included, and a series of
 526  documentation pages that assist the programmer in getting started
 527  with wxPython.
 528
 529  """
 530
 531
 532 #----------------------------------------------------------------------------
 533 #----------------------------------------------------------------------------
 534
 535 if __name__ == '__main__':
 536     main()
 537
 538 #----------------------------------------------------------------------------
 539
 540
 541
 542
 543
 544
 545