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