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