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