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 # FIXME List:
  15 # * Problems with flickering related to ERASE_BACKGROUND
  16 #     and the splitters. Might be a problem with this 2.5 beta...?
  17 #     UPDATE: can't see on 2.5.2 GTK - maybe just a faster machine :)
  18 # * Demo Code menu?
  19 # * Annoying switching between tabs and resulting flicker
  20 #     how to replace a page in the notebook without deleting/adding?
  21 #     Where is SetPage!? tried freeze...tried reparent of dummy panel....
  22
  23 # TODO List:
  24 # * UI design more prefessional
  25 # * save file positions (new field in demoModules) (@ LoadDemoSource)
  26 # * Update main overview
  27
  28 # * Why don't we move _treeList into a separate module
  29
  30 import sys, os, time, traceback, types
  31
  32 import wx                  # This module uses the new wx namespace
  33 import wx.html
  34
  35 import images
  36
  37 # For debugging
  38 ##wx.Trap();
  39 ##print "wx.VERSION_STRING = ", wx.VERSION_STRING
  40 ##print os.getpid();
  41 ##raw_input("Press Enter...")
  42
  43
  44 #---------------------------------------------------------------------------
  45
  46
  47 _treeList = [
  48     # new stuff
  49     ('Recent Additions/Updates', [
  50         'OGL',
  51         'FloatCanvas',
  52         ]),
  53
  54     # managed windows == things with a (optional) caption you can close
  55     ('Frames and Dialogs', [
  56         'Dialog',
  57         'Frame',
  58         'MDIWindows',
  59         'MiniFrame',
  60         'Wizard',
  61         ]),
  62
  63     # the common dialogs
  64     ('Common Dialogs', [
  65         'ColourDialog',
  66         'DirDialog',
  67         'FileDialog',
  68         'FindReplaceDialog',
  69         'FontDialog',
  70         'MessageDialog',
  71         'PageSetupDialog',
  72         'PrintDialog',
  73         'ProgressDialog',
  74         'SingleChoiceDialog',
  75         'TextEntryDialog',
  76         ]),
  77
  78     # dialogs from libraries
  79     ('More Dialogs', [
  80         'ImageBrowser',
  81         'MultipleChoiceDialog',
  82         'ScrolledMessageDialog',
  83         ]),
  84
  85     # core controls
  86     ('Core Windows/Controls', [
  87         'BitmapButton',
  88         'Button',
  89         'CheckBox',
  90         'CheckListBox',
  91         'Choice',
  92         'ComboBox',
  93         'Gauge',
  94         'Grid',
  95         'Grid_MegaExample',
  96         'ListBox',
  97         'ListCtrl',
  98         'ListCtrl_virtual',
  99         'Listbook',
 100         'Menu',
 101         'Notebook',
 102         'PopupMenu',
 103         'PopupWindow',
 104         'RadioBox',
 105         'RadioButton',
 106         'SashWindow',
 107         'ScrolledWindow',
 108         'Slider',
 109         'SpinButton',
 110         'SpinCtrl',
 111         'SplitterWindow',
 112         'StaticBitmap',
 113         'StaticText',
 114         'StatusBar',
 115         'TextCtrl',
 116         'ToggleButton',
 117         'ToolBar',
 118         'TreeCtrl',
 119         'Validator',
 120         ]),
 121
 122     ('Custom Controls', [
 123         'AnalogClockWindow',
 124         'ColourSelect',
 125         'Editor',
 126         'GenericButtons',
 127         'GenericDirCtrl',
 128         'LEDNumberCtrl',
 129         'MultiSash',
 130         'PopupControl',
 131         'PyColourChooser',
 132         'TreeListCtrl',
 133     ]),
 134
 135     # controls coming from other libraries
 136     ('More Windows/Controls', [
 137         'ActiveX_FlashWindow',
 138         'ActiveX_IEHtmlWindow',
 139         'ActiveX_PDFWindow',
 140         #'RightTextCtrl',     deprecated as we have wxTE_RIGHT now.
 141         'Calendar',
 142         'CalendarCtrl',
 143         'ContextHelp',
 144         'DynamicSashWindow',
 145         'EditableListBox',
 146         'FancyText',
 147         'FileBrowseButton',
 148         'FloatBar',
 149         'FloatCanvas',
 150         'HtmlWindow',
 151         'IntCtrl',
 152         'MVCTree',
 153         'MaskedEditControls',
 154         'MaskedNumCtrl',
 155         'MimeTypesManager',
 156         'PyCrust',
 157         'PyPlot',
 158         'PyShell',
 159         'ScrolledPanel',
 160         'SplitTree',
 161         'StyledTextCtrl_1',
 162         'StyledTextCtrl_2',
 163         'TablePrint',
 164         'Throbber',
 165         'TimeCtrl',
 166         'VListBox',
 167         ]),
 168
 169     # How to lay out the controls in a frame/dialog
 170     ('Window Layout', [
 171         'GridBagSizer',
 172         'LayoutAnchors',
 173         'LayoutConstraints',
 174         'Layoutf',
 175         'RowColSizer',
 176         'ScrolledPanel',
 177         'Sizers',
 178         'XmlResource',
 179         'XmlResourceHandler',
 180         'XmlResourceSubclass',
 181         ]),
 182
 183     # ditto
 184     ('Process and Events', [
 185         'EventManager',
 186         'KeyEvents',
 187         'Process',
 188         'PythonEvents',
 189         'Threads',
 190         'Timer',
 191         ##'infoframe',    # needs better explaination and some fixing
 192         ]),
 193
 194     # Clipboard and DnD
 195     ('Clipboard and DnD', [
 196         'CustomDragAndDrop',
 197         'DragAndDrop',
 198         'URLDragAndDrop',
 199         ]),
 200
 201     # Images
 202     ('Using Images', [
 203         'ArtProvider',
 204         'Cursor',
 205         'DragImage',
 206         'Image',
 207         'ImageAlpha',
 208         'ImageFromStream',
 209         'Mask',
 210         'Throbber',
 211         ]),
 212
 213     # Other stuff
 214     ('Miscellaneous', [
 215         'ColourDB',
 216         ##'DialogUnits',   # needs more explainations
 217         'DrawXXXList',
 218         'FileHistory',
 219         'FontEnumerator',
 220         'Joystick',
 221         'OGL',
 222         'PrintFramework',
 223         'ShapedWindow',
 224         'Sound',
 225         'Unicode',
 226         ]),
 227
 228     # need libs not coming with the demo
 229     ('Samples using an external library', [
 230         'GLCanvas',
 231         ]),
 232
 233
 234     ('Check out the samples dir too', [
 235         ]),
 236
 237 ]
 238
 239
 240
 241 #---------------------------------------------------------------------------
 242 # Show how to derive a custom wxLog class
 243
 244 class MyLog(wx.PyLog):
 245     def __init__(self, textCtrl, logTime=0):
 246         wx.PyLog.__init__(self)
 247         self.tc = textCtrl
 248         self.logTime = logTime
 249
 250     def DoLogString(self, message, timeStamp):
 251         if self.logTime:
 252             message = time.strftime("%X", time.localtime(timeStamp)) + \
 253                       ": " + message
 254         if self.tc:
 255             self.tc.AppendText(message + '\n')
 256
 257
 258 class MyTP(wx.PyTipProvider):
 259     def GetTip(self):
 260         return "This is my tip"
 261
 262
 263 #---------------------------------------------------------------------------
 264 # A class to be used to display source code in the demo.  Try using the
 265 # wxSTC in the StyledTextCtrl_2 sample first, fall back to wxTextCtrl
 266 # if there is an error, such as the stc module not being present.
 267 #
 268
 269 try:
 270     ##raise ImportError     # for testing the alternate implementation
 271     from wx import stc
 272     from StyledTextCtrl_2 import PythonSTC
 273
 274     class DemoCodeEditor(PythonSTC):
 275         def __init__(self, parent):
 276             PythonSTC.__init__(self, parent, -1, wx.BORDER_NONE)
 277             self.SetUpEditor()
 278
 279         # Some methods to make it compatible with how the wxTextCtrl is used
 280         def SetValue(self, value):
 281             if wx.USE_UNICODE:
 282                 value = value.decode('iso8859_1')
 283             self.SetText(value)
 284             self.EmptyUndoBuffer()
 285             self.SetSavePoint()
 286
 287         def IsModified(self):
 288             return self.GetModify()
 289
 290         def Clear(self):
 291             self.ClearAll()
 292
 293         def SetInsertionPoint(self, pos):
 294             self.SetCurrentPos(pos)
 295             self.SetAnchor(pos)
 296
 297         def ShowPosition(self, pos):
 298             line = self.LineFromPosition(pos)
 299             #self.EnsureVisible(line)
 300             self.GotoLine(line)
 301
 302         def GetLastPosition(self):
 303             return self.GetLength()
 304
 305         def GetPositionFromLine(self, line):
 306             return self.PositionFromLine(line)
 307
 308         def GetRange(self, start, end):
 309             return self.GetTextRange(start, end)
 310
 311         def GetSelection(self):
 312             return self.GetAnchor(), self.GetCurrentPos()
 313
 314         def SetSelection(self, start, end):
 315             self.SetSelectionStart(start)
 316             self.SetSelectionEnd(end)
 317
 318         def SelectLine(self, line):
 319             start = self.PositionFromLine(line)
 320             end = self.GetLineEndPosition(line)
 321             self.SetSelection(start, end)
 322
 323         def SetUpEditor(self):
 324             """
 325             This method carries out the work of setting up the demo editor.
 326             It's seperate so as not to clutter up the init code.
 327             """
 328             import keyword
 329
 330             self.SetLexer(stc.STC_LEX_PYTHON)
 331             self.SetKeyWords(0, " ".join(keyword.kwlist))
 332
 333             # Enable folding
 334             self.SetProperty("fold", "1" )
 335
 336             # Highlight tab/space mixing (shouldn't be any)
 337             self.SetProperty("tab.timmy.whinge.level", "1")
 338
 339             # Set left and right margins
 340             self.SetMargins(2,2)
 341
 342             # Set up the numbers in the margin for margin #1
 343             self.SetMarginType(1, wx.stc.STC_MARGIN_NUMBER)
 344             # Reasonable value for, say, 4-5 digits using a mono font (40 pix)
 345             self.SetMarginWidth(1, 40)
 346
 347             # Indentation and tab stuff
 348             self.SetIndent(4)               # Proscribed indent size for wx
 349             self.SetIndentationGuides(True) # Show indent guides
 350             self.SetBackSpaceUnIndents(True)# Backspace unindents rather than delete 1 space
 351             self.SetTabIndents(True)        # Tab key indents
 352             self.SetTabWidth(4)             # Proscribed tab size for wx
 353             self.SetUseTabs(False)          # Use spaces rather than tabs, or
 354                                             # TabTimmy will complain!
 355             # White space
 356             self.SetViewWhiteSpace(False)   # Don't view white space
 357
 358             # EOL: Since we are loading/saving ourselves, and the
 359             # strings will always have \n's in them, set the STC to
 360             # edit them that way.
 361             self.SetEOLMode(wx.stc.STC_EOL_LF)
 362             self.SetViewEOL(False)
 363
 364             # No right-edge mode indicator
 365             self.SetEdgeMode(stc.STC_EDGE_NONE)
 366
 367             # Setup a margin to hold fold markers
 368             self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
 369             self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
 370             self.SetMarginSensitive(2, True)
 371             self.SetMarginWidth(2, 12)
 372
 373             # and now set up the fold markers
 374             self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_BOXPLUSCONNECTED,  "white", "black")
 375             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "black")
 376             self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER,  "white", "black")
 377             self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNER,  "white", "black")
 378             self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,    "white", "black")
 379             self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_BOXPLUS,  "white", "black")
 380             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_BOXMINUS, "white", "black")
 381
 382             # Global default style
 383             if wx.Platform == '__WXMSW__':
 384                 self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
 385                                   'fore:#000000,back:#FFFFFF,face:Courier New,size:9')
 386             else:
 387                 self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
 388                                   'fore:#000000,back:#FFFFFF,face:Courier,size:12')
 389
 390             # Clear styles and revert to default.
 391             self.StyleClearAll()
 392
 393             # Following style specs only indicate differences from default.
 394             # The rest remains unchanged.
 395
 396             # Line numbers in margin
 397             self.StyleSetSpec(wx.stc.STC_STYLE_LINENUMBER,'fore:#000000,back:#99A9C2')
 398
 399             # Highlighted brace
 400             self.StyleSetSpec(wx.stc.STC_STYLE_BRACELIGHT,'fore:#00009D,back:#FFFF00')
 401             # Unmatched brace
 402             self.StyleSetSpec(wx.stc.STC_STYLE_BRACEBAD,'fore:#00009D,back:#FF0000')
 403             # Indentation guide
 404             self.StyleSetSpec(wx.stc.STC_STYLE_INDENTGUIDE, "fore:#CDCDCD")
 405
 406             # Python styles
 407             self.StyleSetSpec(wx.stc.STC_P_DEFAULT, 'fore:#000000')
 408             # Comments
 409             self.StyleSetSpec(wx.stc.STC_P_COMMENTLINE,  'fore:#008000,back:#F0FFF0')
 410             self.StyleSetSpec(wx.stc.STC_P_COMMENTBLOCK, 'fore:#008000,back:#F0FFF0')
 411             # Numbers
 412             self.StyleSetSpec(wx.stc.STC_P_NUMBER, 'fore:#008080')
 413             # Strings and characters
 414             self.StyleSetSpec(wx.stc.STC_P_STRING, 'fore:#800080')
 415             self.StyleSetSpec(wx.stc.STC_P_CHARACTER, 'fore:#800080')
 416             # Keywords
 417             self.StyleSetSpec(wx.stc.STC_P_WORD, 'fore:#000080,bold')
 418             # Triple quotes
 419             self.StyleSetSpec(wx.stc.STC_P_TRIPLE, 'fore:#800080,back:#FFFFEA')
 420             self.StyleSetSpec(wx.stc.STC_P_TRIPLEDOUBLE, 'fore:#800080,back:#FFFFEA')
 421             # Class names
 422             self.StyleSetSpec(wx.stc.STC_P_CLASSNAME, 'fore:#0000FF,bold')
 423             # Function names
 424             self.StyleSetSpec(wx.stc.STC_P_DEFNAME, 'fore:#008080,bold')
 425             # Operators
 426             self.StyleSetSpec(wx.stc.STC_P_OPERATOR, 'fore:#800000,bold')
 427             # Identifiers. I leave this as not bold because everything seems
 428             # to be an identifier if it doesn't match the above criterae
 429             self.StyleSetSpec(wx.stc.STC_P_IDENTIFIER, 'fore:#000000')
 430
 431             # Caret color
 432             self.SetCaretForeground("BLUE")
 433             # Selection background
 434             self.SetSelBackground(1, '#66CCFF')
 435
 436             self.SetSelBackground(True, wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHT))
 437             self.SetSelForeground(True, wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHTTEXT))
 438
 439         def RegisterModifiedEvent(self, eventHandler):
 440             self.Bind(wx.stc.EVT_STC_CHANGE, eventHandler)
 441
 442
 443 except ImportError:
 444     class DemoCodeEditor(wx.TextCtrl):
 445         def __init__(self, parent):
 446             wx.TextCtrl.__init__(self, parent, -1, style = wx.TE_MULTILINE |
 447                                  wx.HSCROLL | wx.TE_RICH2 | wx.TE_NOHIDESEL)
 448
 449         def RegisterModifiedEvent(self, eventHandler):
 450             self.Bind(wx.EVT_TEXT, eventHandler)
 451
 452         def SetReadOnly(self, flag):
 453             self.SetEditable(not flag)
 454             # NOTE: STC already has this method
 455
 456         def GetText(self):
 457             return self.GetValue()
 458
 459         def GetPositionFromLine(line):
 460             return self.XYToPosition(0,line)
 461
 462         def GotoLine(self, line):
 463             pos = self.editor.GetPositionFromLine(line)
 464             self.editor.SetInsertionPoint(pos)
 465             self.editor.ShowPosition(pos)
 466
 467         def SelectLine(self, line):
 468             start = self.GetPositionFromLine(line)
 469             end = start + self.GetLineLength(line)
 470             self.SetSelection(start, end)
 471
 472
 473 #---------------------------------------------------------------------------
 474 # Constants for module versions
 475
 476 modOriginal = 0
 477 modModified = 1
 478 modDefault = modOriginal
 479
 480 #---------------------------------------------------------------------------
 481
 482 class DemoCodePanel(wx.Panel):
 483     """Panel for the 'Demo Code' tab"""
 484     def __init__(self, parent, mainFrame):
 485         wx.Panel.__init__(self, parent)
 486         self.mainFrame = mainFrame
 487         self.editor = DemoCodeEditor(self)
 488         self.editor.RegisterModifiedEvent(self.OnCodeModified)
 489
 490         self.btnSave = wx.Button(self, -1, "Save Changes")
 491         self.btnRestore = wx.Button(self, -1, "Delete Modified")
 492         self.btnSave.Enable(False)
 493         self.btnSave.Bind(wx.EVT_BUTTON, self.OnSave)
 494         self.btnRestore.Bind(wx.EVT_BUTTON, self.OnRestore)
 495
 496         self.radioButtons = { modOriginal: wx.RadioButton(self, -1, "Original", style = wx.RB_GROUP),
 497                               modModified: wx.RadioButton(self, -1, "Modified") }
 498
 499         self.controlBox = wx.BoxSizer(wx.HORIZONTAL)
 500         self.controlBox.Add(wx.StaticText(self, -1, "Active Version:"), 0,
 501                             wx.RIGHT | wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 5)
 502         for modID, radioButton in self.radioButtons.items():
 503             self.controlBox.Add(radioButton, 0, wx.EXPAND | wx.RIGHT, 5)
 504             radioButton.modID = modID # makes it easier for the event handler
 505             radioButton.Bind(wx.EVT_RADIOBUTTON, self.OnRadioButton)
 506
 507         self.controlBox.Add(self.btnSave, 0, wx.RIGHT, 5)
 508         self.controlBox.Add(self.btnRestore, 0)
 509
 510         self.box = wx.BoxSizer(wx.VERTICAL)
 511         self.box.Add(self.controlBox, 0, wx.EXPAND)
 512         self.box.Add(wx.StaticLine(self), 0, wx.EXPAND)
 513         self.box.Add(self.editor, 1, wx.EXPAND)
 514
 515         self.box.Fit(self)
 516         self.SetSizer(self.box)
 517
 518
 519     # Loads a demo from a DemoModules object
 520     def LoadDemo(self, demoModules):
 521         self.demoModules = demoModules
 522         if (modDefault == modModified) and demoModules.Exists(modModified):
 523             demoModules.SetActive(modModified)
 524         else:
 525             demoModules.SetActive(modOriginal)
 526         self.radioButtons[demoModules.GetActiveID()].Enable(True)
 527         self.ActiveModuleChanged()
 528
 529
 530     def ActiveModuleChanged(self):
 531         self.LoadDemoSource(self.demoModules.GetSource())
 532         self.UpdateControlState()
 533         self.ReloadDemo()
 534
 535
 536     def LoadDemoSource(self, source):
 537         self.editor.Clear()
 538         self.editor.SetValue(source)
 539         self.JumpToLine(0)
 540         self.btnSave.Enable(False)
 541
 542
 543     def JumpToLine(self, line, highlight=False):
 544         self.editor.GotoLine(line)
 545         self.editor.SetFocus()
 546         if highlight:
 547             self.editor.SelectLine(line)
 548
 549
 550     def UpdateControlState(self):
 551         active = self.demoModules.GetActiveID()
 552         # Update the radio/restore buttons
 553         for moduleID in self.radioButtons:
 554             btn = self.radioButtons[moduleID]
 555             if moduleID == active:
 556                 btn.SetValue(True)
 557             else:
 558                 btn.SetValue(False)
 559
 560             if self.demoModules.Exists(moduleID):
 561                 btn.Enable(True)
 562                 if moduleID == modModified:
 563                     self.btnRestore.Enable(True)
 564             else:
 565                 btn.Enable(False)
 566                 if moduleID == modModified:
 567                     self.btnRestore.Enable(False)
 568
 569
 570     def OnRadioButton(self, event):
 571         radioSelected = event.GetEventObject()
 572         modSelected = radioSelected.modID
 573         if modSelected != self.demoModules.GetActiveID():
 574             busy = wx.BusyInfo("Reloading demo module...")
 575             self.demoModules.SetActive(modSelected)
 576             self.ActiveModuleChanged()
 577
 578
 579     def ReloadDemo(self):
 580         if self.demoModules.name != __name__:
 581             self.mainFrame.RunModule()
 582
 583
 584     def OnCodeModified(self, event):
 585         self.btnSave.Enable(self.editor.IsModified())
 586
 587
 588     def OnSave(self, event):
 589         if self.demoModules.Exists(modModified):
 590             if self.demoModules.GetActiveID() == modOriginal:
 591                 overwriteMsg = "You are about to overwrite an already existing modified copy\n" + \
 592                                "Do you want to continue?"
 593                 dlg = wx.MessageDialog(self, overwriteMsg, "wxPython Demo",
 594                                        wx.YES_NO | wx.NO_DEFAULT| wx.ICON_EXCLAMATION)
 595                 result = dlg.ShowModal()
 596                 if result == wx.ID_NO:
 597                     return
 598                 dlg.Destroy()
 599
 600         self.demoModules.SetActive(modModified)
 601         modifiedFilename = GetModifiedFilename(self.demoModules.name)
 602
 603         # Create the demo directory if one doesn't already exist
 604         if not os.path.exists(GetModifiedDirectory()):
 605             try:
 606                 os.makedirs(GetModifiedDirectory())
 607                 if not os.path.exists(GetModifiedDirectory()):
 608                     wx.LogMessage("BUG: Created demo directory but it still doesn't exit")
 609                     raise AssetionError
 610             except:
 611                 wx.LogMessage("Error creating demo directory: %s" % GetModifiedDirectory())
 612                 return
 613             else:
 614                 wx.LogMessage("Created directory for modified demos: %s" % GetModifiedDirectory())
 615
 616         # Save
 617         f = open(modifiedFilename, "wt")
 618         source = self.editor.GetText()
 619         try:
 620             f.write(source)
 621         finally:
 622             f.close()
 623
 624         busy = wx.BusyInfo("Reloading demo module...")
 625         self.demoModules.LoadFromFile(modModified, modifiedFilename)
 626         self.ActiveModuleChanged()
 627
 628
 629     def OnRestore(self, event): # Handles the "Delete Modified" button
 630         modifiedFilename = GetModifiedFilename(self.demoModules.name)
 631         self.demoModules.Delete(modModified)
 632         os.unlink(modifiedFilename) # Delete the modified copy
 633         busy = wx.BusyInfo("Reloading demo module...")
 634         self.ActiveModuleChanged()
 635
 636
 637 #---------------------------------------------------------------------------
 638
 639 def opj(path):
 640     """Convert paths to the platform-specific separator"""
 641     str = apply(os.path.join, tuple(path.split('/')))
 642     # HACK: on Linux, a leading / gets lost...
 643     if path.startswith('/'):
 644         str = '/' + str
 645     return str
 646
 647
 648 def GetModifiedDirectory():
 649     """
 650     Returns the directory where modified versions of the demo files
 651     are stored
 652     """
 653     return opj(wx.GetHomeDir() + "/.wxPyDemo/modified/")
 654
 655
 656 def GetModifiedFilename(name):
 657     """
 658     Returns the filename of the modified version of the specified demo
 659     """
 660     if not name.endswith(".py"):
 661         name = name + ".py"
 662     return GetModifiedDirectory() + name
 663
 664
 665 def GetOriginalFilename(name):
 666     """
 667     Returns the filename of the original version of the specified demo
 668     """
 669     if not name.endswith(".py"):
 670         name = name + ".py"
 671     return name
 672
 673
 674 def DoesModifiedExist(name):
 675     """Returns whether the specified demo has a modified copy"""
 676     if os.path.exists(GetModifiedFilename(name)):
 677         return True
 678     else:
 679         return False
 680
 681
 682 #---------------------------------------------------------------------------
 683
 684 class ModuleDictWrapper:
 685     """Emulates a module with a dynamically compiled __dict__"""
 686     def __init__(self, dict):
 687         self.dict = dict
 688
 689     def __getattr__(self, name):
 690         if name in self.dict:
 691             return self.dict[name]
 692         else:
 693             raise AttributeError
 694
 695 class DemoModules:
 696     """
 697     Dynamically manages the original/modified versions of a demo
 698     module
 699     """
 700     def __init__(self, name):
 701         self.modActive = -1
 702         self.name = name
 703
 704         #              (dict , source ,  filename , description   , error information )
 705         #              (  0  ,   1    ,     2     ,      3        ,          4        )
 706         self.modules = [[None,  ""    ,    ""     , "<original>"  ,        None],
 707                         [None,  ""    ,    ""     , "<modified>"  ,        None]]
 708
 709         # load original module
 710         self.LoadFromFile(modOriginal, GetOriginalFilename(name))
 711         self.SetActive(modOriginal)
 712
 713         # load modified module (if one exists)
 714         if DoesModifiedExist(name):
 715            self.LoadFromFile(modModified, GetModifiedFilename(name))
 716
 717
 718     def LoadFromFile(self, modID, filename):
 719         self.modules[modID][2] = filename
 720         file = open(filename, "rt")
 721         self.LoadFromSource(modID, file.read())
 722         file.close()
 723
 724
 725     def LoadFromSource(self, modID, source):
 726         self.modules[modID][1] = source
 727         self.LoadDict(modID)
 728
 729
 730     def LoadDict(self, modID):
 731         if self.name != __name__:
 732             source = self.modules[modID][1]
 733             description = self.modules[modID][3]
 734
 735             try:
 736                 self.modules[modID][0] = {}
 737                 code = compile(source, description, "exec")
 738                 exec code in self.modules[modID][0]
 739             except:
 740                 self.modules[modID][4] = DemoError(sys.exc_info())
 741                 self.modules[modID][0] = None
 742             else:
 743                 self.modules[modID][4] = None
 744
 745
 746     def SetActive(self, modID):
 747         if modID != modOriginal and modID != modModified:
 748             raise LookupError
 749         else:
 750             self.modActive = modID
 751
 752
 753     def GetActive(self):
 754         dict = self.modules[self.modActive][0]
 755         if dict is None:
 756             return None
 757         else:
 758             return ModuleDictWrapper(dict)
 759
 760
 761     def GetActiveID(self):
 762         return self.modActive
 763
 764
 765     def GetSource(self, modID = None):
 766         if modID is None:
 767             modID = self.modActive
 768         return self.modules[modID][1]
 769
 770
 771     def GetFilename(self, modID = None):
 772         if modID is None:
 773             modID = self.modActive
 774         return self.modules[self.modActive][2]
 775
 776
 777     def GetErrorInfo(self, modID = None):
 778         if modID is None:
 779             modID = self.modActive
 780         return self.modules[self.modActive][4]
 781
 782
 783     def Exists(self, modID):
 784         return self.modules[modID][1] != ""
 785
 786
 787     def UpdateFile(self, modID = None):
 788         """Updates the file from which a module was loaded
 789         with (possibly updated) source"""
 790         if modID is None:
 791             modID = self.modActive
 792
 793         source = self.modules[modID][1]
 794         filename = self.modules[modID][2]
 795
 796         try:
 797             file = open(filename, "wt")
 798             file.write(source)
 799         finally:
 800             file.close()
 801
 802
 803     def Delete(self, modID):
 804         if self.modActive == modID:
 805             self.SetActive(0)
 806
 807         self.modules[modID][0] = None
 808         self.modules[modID][1] = ""
 809         self.modules[modID][2] = ""
 810
 811
 812 #---------------------------------------------------------------------------
 813
 814 class DemoError:
 815     """Wraps and stores information about the current exception"""
 816     def __init__(self, exc_info):
 817         import copy
 818
 819         excType, excValue = exc_info[:2]
 820         # traceback list entries: (filename, line number, function name, text)
 821         self.traceback = traceback.extract_tb(exc_info[2])
 822
 823         # --Based on traceback.py::format_exception_only()--
 824         if type(excType) == types.ClassType:
 825             self.exception_type = excType.__name__
 826         else:
 827             self.exception_type = excType
 828
 829         # If it's a syntax error, extra information needs
 830         # to be added to the traceback
 831         if excType is SyntaxError:
 832             try:
 833                 msg, (filename, lineno, self.offset, line) = excValue
 834             except:
 835                 pass
 836             else:
 837                 if not filename:
 838                     filename = "<string>"
 839                 line = line.strip()
 840                 self.traceback.append( (filename, lineno, "", line) )
 841                 excValue = msg
 842         try:
 843             self.exception_details = str(excValue)
 844         except:
 845             self.exception_details = "<unprintable %s object>" & type(excValue).__name__
 846
 847         del exc_info
 848
 849     def __str__(self):
 850         ret = "Type %s \n \
 851         Traceback: %s \n \
 852         Details  : %s" % ( str(self.exception_type), str(self.traceback), self.exception_details )
 853         return ret
 854
 855 #---------------------------------------------------------------------------
 856
 857 class DemoErrorPanel(wx.Panel):
 858     """Panel put into the demo tab when the demo fails to run due  to errors"""
 859
 860     def __init__(self, parent, codePanel, demoError, log):
 861         wx.Panel.__init__(self, parent, -1)#, style=wx.NO_FULL_REPAINT_ON_RESIZE)
 862         self.codePanel = codePanel
 863         self.nb = parent
 864         self.log = log
 865
 866         self.box = wx.BoxSizer(wx.VERTICAL)
 867
 868         # Main Label
 869         self.box.Add(wx.StaticText(self, -1, "An error has occured while trying to run the demo")
 870                      , 0, wx.ALIGN_CENTER | wx.TOP, 10)
 871
 872         # Exception Information
 873         boxInfo      = wx.StaticBox(self, -1, "Exception Info" )
 874         boxInfoSizer = wx.StaticBoxSizer(boxInfo, wx.VERTICAL ) # Used to center the grid within the box
 875         boxInfoGrid  = wx.FlexGridSizer(0, 2, 0, 0)
 876         textFlags    = wx.ALIGN_RIGHT | wx.LEFT | wx.RIGHT | wx.TOP
 877         boxInfoGrid.Add(wx.StaticText(self, -1, "Type: "), 0, textFlags, 5 )
 878         boxInfoGrid.Add(wx.StaticText(self, -1, demoError.exception_type) , 0, textFlags, 5 )
 879         boxInfoGrid.Add(wx.StaticText(self, -1, "Details: ") , 0, textFlags, 5 )
 880         boxInfoGrid.Add(wx.StaticText(self, -1, demoError.exception_details) , 0, textFlags, 5 )
 881         boxInfoSizer.Add(boxInfoGrid, 0, wx.ALIGN_CENTRE | wx.ALL, 5 )
 882         self.box.Add(boxInfoSizer, 0, wx.ALIGN_CENTER | wx.ALL, 5)
 883
 884         # Set up the traceback list
 885         # This one automatically resizes last column to take up remaining space
 886         from ListCtrl import TestListCtrl
 887         self.list = TestListCtrl(self, -1, style=wx.LC_REPORT  | wx.SUNKEN_BORDER)
 888         self.list.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
 889         self.list.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected)
 890         self.list.InsertColumn(0, "Filename")
 891         self.list.InsertColumn(1, "Line", wx.LIST_FORMAT_RIGHT)
 892         self.list.InsertColumn(2, "Function")
 893         self.list.InsertColumn(3, "Code")
 894         self.InsertTraceback(self.list, demoError.traceback)
 895         self.list.SetColumnWidth(0, wx.LIST_AUTOSIZE)
 896         self.list.SetColumnWidth(2, wx.LIST_AUTOSIZE)
 897         self.box.Add(wx.StaticText(self, -1, "Traceback:")
 898                      , 0, wx.ALIGN_CENTER | wx.TOP, 5)
 899         self.box.Add(self.list, 1, wx.GROW | wx.ALIGN_CENTER | wx.ALL, 5)
 900         self.box.Add(wx.StaticText(self, -1, "Entries from the demo module are shown in blue\n"
 901                                            + "Double-click on them to go to the offending line")
 902                      , 0, wx.ALIGN_CENTER | wx.BOTTOM, 5)
 903
 904         self.box.Fit(self)
 905         self.SetSizer(self.box)
 906
 907
 908     def InsertTraceback(self, list, traceback):
 909         #Add the traceback data
 910         for x in range(len(traceback)):
 911             data = traceback[x]
 912             list.InsertStringItem(x, os.path.basename(data[0])) # Filename
 913             list.SetStringItem(x, 1, str(data[1]))              # Line
 914             list.SetStringItem(x, 2, str(data[2]))              # Function
 915             list.SetStringItem(x, 3, str(data[3]))              # Code
 916
 917             # Check whether this entry is from the demo module
 918             if data[0] == "<original>" or data[0] == "<modified>": # FIXME: make more generalised
 919                 self.list.SetItemData(x, int(data[1]))   # Store line number for easy access
 920                 # Give it a blue colour
 921                 item = self.list.GetItem(x)
 922                 item.SetTextColour(wx.BLUE)
 923                 self.list.SetItem(item)
 924             else:
 925                 self.list.SetItemData(x, -1)        # Editor can't jump into this one's code
 926
 927
 928     def OnItemSelected(self, event):
 929         # This occurs before OnDoubleClick and can be used to set the
 930         # currentItem. OnDoubleClick doesn't get a wxListEvent....
 931         self.currentItem = event.m_itemIndex
 932         event.Skip()
 933
 934
 935     def OnDoubleClick(self, event):
 936         # If double-clicking on a demo's entry, jump to the line number
 937         line = self.list.GetItemData(self.currentItem)
 938         if line != -1:
 939             self.nb.SetSelection(1) # Switch to the code viewer tab
 940             wx.CallAfter(self.codePanel.JumpToLine, line-1, True)
 941         event.Skip()
 942
 943
 944 #---------------------------------------------------------------------------
 945
 946 class wxPythonDemo(wx.Frame):
 947     overviewText = "wxPython Overview"
 948
 949     def __init__(self, parent, title):
 950         wx.Frame.__init__(self, parent, -1, title, size = (950, 720),
 951                           style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
 952
 953         self.loaded = False
 954         self.cwd = os.getcwd()
 955         self.curOverview = ""
 956         self.demoPage = None
 957         self.codePage = None
 958         self.shell = None
 959         self.firstTime = True
 960
 961         icon = images.getMondrianIcon()
 962         self.SetIcon(icon)
 963
 964         if wx.Platform != '__WXMAC__':
 965             # setup a taskbar icon, and catch some events from it
 966             dim = 16  # (may want to use 22 on wxGTK, but 16 looks okay too)
 967             icon = wx.IconFromBitmap(
 968                 images.getMondrianImage().Scale(dim,dim).ConvertToBitmap() )
 969             #icon = wx.Icon('bmp_source/mondrian.ico', wx.BITMAP_TYPE_ICO)
 970             #icon = images.getMondrianIcon()
 971             self.tbicon = wx.TaskBarIcon()
 972             self.tbicon.SetIcon(icon, "wxPython Demo")
 973             self.tbicon.Bind(wx.EVT_TASKBAR_LEFT_DCLICK, self.OnTaskBarActivate)
 974             self.tbicon.Bind(wx.EVT_TASKBAR_RIGHT_UP, self.OnTaskBarMenu)
 975             self.tbicon.Bind(wx.EVT_MENU, self.OnTaskBarActivate, id=self.TBMENU_RESTORE)
 976             self.tbicon.Bind(wx.EVT_MENU, self.OnTaskBarClose, id=self.TBMENU_CLOSE)
 977
 978         wx.CallAfter(self.ShowTip)
 979
 980         self.otherWin = None
 981         self.Bind(wx.EVT_IDLE, self.OnIdle)
 982         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 983         self.Bind(wx.EVT_ICONIZE, self.OnIconfiy)
 984         self.Bind(wx.EVT_MAXIMIZE, self.OnMaximize)
 985
 986         self.Centre(wx.BOTH)
 987         self.CreateStatusBar(1, wx.ST_SIZEGRIP)
 988
 989         splitter = wx.SplitterWindow(self, -1, style=wx.CLIP_CHILDREN | wx.SP_LIVE_UPDATE | wx.SP_3D)
 990         splitter2 = wx.SplitterWindow(splitter, -1, style=wx.CLIP_CHILDREN | wx.SP_LIVE_UPDATE | wx.SP_3D)
 991
 992         def EmptyHandler(evt): pass
 993         #splitter.Bind(wx.EVT_ERASE_BACKGROUND, EmptyHandler)
 994         #splitter2.Bind(wx.EVT_ERASE_BACKGROUND, EmptyHandler)
 995
 996         # Prevent TreeCtrl from displaying all items after destruction when True
 997         self.dying = False
 998
 999         # Create a Notebook
1000         self.nb = wx.Notebook(splitter2, -1, style=wx.CLIP_CHILDREN)
1001
1002         # Make a File menu
1003         self.mainmenu = wx.MenuBar()
1004         menu = wx.Menu()
1005         item = menu.Append(-1, '&Redirect Output',
1006                            'Redirect print statements to a window',
1007                            wx.ITEM_CHECK)
1008         self.Bind(wx.EVT_MENU, self.OnToggleRedirect, item)
1009
1010         item = menu.Append(-1, 'E&xit\tAlt-X', 'Get the heck outta here!')
1011         self.Bind(wx.EVT_MENU, self.OnFileExit, item)
1012         wx.App_SetMacExitMenuItemId(item.GetId())
1013         self.mainmenu.Append(menu, '&File')
1014
1015         # Make a Demo menu
1016         menu = wx.Menu()
1017         for item in _treeList:
1018             submenu = wx.Menu()
1019             for childItem in item[1]:
1020                 mi = submenu.Append(-1, childItem)
1021                 self.Bind(wx.EVT_MENU, self.OnDemoMenu, mi)
1022             menu.AppendMenu(wx.NewId(), item[0], submenu)
1023         self.mainmenu.Append(menu, '&Demo')
1024
1025         # Make a Demo Code menu
1026         #TODO: Add new menu items
1027         #       Like the option-enabled entries to select the
1028         #       active module
1029         #TODO: should we bother?
1030
1031         #menu = wx.Menu()
1032         #saveID = wx.NewId()
1033         #restoreID = wx.NewId()
1034        #
1035         #menu.Append(saveID, '&Save\tCtrl-S', 'Save edited demo')
1036         #menu.Append(restoreID, '&Delete Modified\tCtrl-R', 'Delete modified copy')
1037         #self.Bind(wx.EVT_MENU, self.codePage.OnSave, id=saveID)
1038         #self.Bind(wx.EVT_MENU, self.codePage.OnRestore, id=restoreID)
1039         #self.mainmenu.Append(menu, 'Demo &Code')
1040        #
1041
1042         # Make a Help menu
1043         menu = wx.Menu()
1044         findItem = menu.Append(-1, '&Find\tCtrl-F', 'Find in the Demo Code')
1045         findnextItem = menu.Append(-1, 'Find &Next\tF3', 'Find Next')
1046         menu.AppendSeparator()
1047
1048         shellItem = menu.Append(-1, 'Open Py&Shell Window\tF5',
1049                                 'An interactive interpreter window with the demo app and frame objects in the namesapce')
1050         menu.AppendSeparator()
1051         helpItem = menu.Append(-1, '&About\tCtrl-H', 'wxPython RULES!!!')
1052         wx.App_SetMacAboutMenuItemId(helpItem.GetId())
1053
1054         self.Bind(wx.EVT_MENU, self.OnOpenShellWindow, shellItem)
1055         self.Bind(wx.EVT_MENU, self.OnHelpAbout, helpItem)
1056         self.Bind(wx.EVT_MENU, self.OnHelpFind,  findItem)
1057         self.Bind(wx.EVT_MENU, self.OnFindNext,  findnextItem)
1058         self.Bind(wx.EVT_COMMAND_FIND, self.OnFind)
1059         self.Bind(wx.EVT_COMMAND_FIND_NEXT, self.OnFind)
1060         self.Bind(wx.EVT_COMMAND_FIND_CLOSE, self.OnFindClose)
1061         self.mainmenu.Append(menu, '&Help')
1062         self.SetMenuBar(self.mainmenu)
1063
1064         self.finddata = wx.FindReplaceData()
1065
1066         if 0:
1067             # This is another way to set Accelerators, in addition to
1068             # using the '\t<key>' syntax in the menu items.
1069             aTable = wx.AcceleratorTable([(wx.ACCEL_ALT,  ord('X'), exitID),
1070                                           (wx.ACCEL_CTRL, ord('H'), helpID),
1071                                           (wx.ACCEL_CTRL, ord('F'), findID),
1072                                           (wx.ACCEL_NORMAL, WXK_F3, findnextID)
1073                                           ])
1074             self.SetAcceleratorTable(aTable)
1075
1076
1077         # Create a TreeCtrl
1078         tID = wx.NewId()
1079         self.treeMap = {}
1080         self.tree = wx.TreeCtrl(splitter, tID, style =
1081                                 wx.TR_DEFAULT_STYLE #| wx.TR_HAS_VARIABLE_ROW_HEIGHT
1082                                )
1083
1084         root = self.tree.AddRoot("wxPython Overview")
1085         firstChild = None
1086         for item in _treeList:
1087             child = self.tree.AppendItem(root, item[0])
1088             if not firstChild: firstChild = child
1089             for childItem in item[1]:
1090                 theDemo = self.tree.AppendItem(child, childItem)
1091                 self.treeMap[childItem] = theDemo
1092
1093         self.tree.Expand(root)
1094         self.tree.Expand(firstChild)
1095         self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded, id=tID)
1096         self.tree.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, id=tID)
1097         self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, id=tID)
1098         self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)
1099
1100         # Set up a wx.html.HtmlWindow on the Overview Notebook page
1101         # we put it in a panel first because there seems to be a
1102         # refresh bug of some sort (wxGTK) when it is directly in
1103         # the notebook...
1104         if 0:  # the old way
1105             self.ovr = wx.html.HtmlWindow(self.nb, -1, size=(400, 400))
1106             self.nb.AddPage(self.ovr, self.overviewText)
1107
1108         else:  # hopefully I can remove this hacky code soon, see SF bug #216861
1109             panel = wx.Panel(self.nb, -1, style=wx.CLIP_CHILDREN)
1110             self.ovr = wx.html.HtmlWindow(panel, -1, size=(400, 400))
1111             self.nb.AddPage(panel, self.overviewText)
1112
1113             def OnOvrSize(evt, ovr=self.ovr):
1114                 ovr.SetSize(evt.GetSize())
1115             panel.Bind(wx.EVT_SIZE, OnOvrSize)
1116             panel.Bind(wx.EVT_ERASE_BACKGROUND, EmptyHandler)
1117
1118         if "gtk2" in wx.PlatformInfo:
1119             self.ovr.NormalizeFontSizes()
1120         self.SetOverview(self.overviewText, mainOverview)
1121
1122
1123         # Set up a log window
1124         self.log = wx.TextCtrl(splitter2, -1,
1125                               style = wx.TE_MULTILINE|wx.TE_READONLY|wx.HSCROLL)
1126
1127         # Set the wxWindows log target to be this textctrl
1128         #wx.Log_SetActiveTarget(wx.LogTextCtrl(self.log))
1129
1130         # But instead of the above we want to show how to use our own wx.Log class
1131         wx.Log_SetActiveTarget(MyLog(self.log))
1132
1133         # for serious debugging
1134         #wx.Log_SetActiveTarget(wx.LogStderr())
1135         #wx.Log_SetTraceMask(wx.TraceMessages)
1136
1137
1138         # add the windows to the splitter and split it.
1139         splitter2.SplitHorizontally(self.nb, self.log, -160)
1140         splitter.SplitVertically(self.tree, splitter2, 200)
1141
1142         splitter.SetMinimumPaneSize(20)
1143         splitter2.SetMinimumPaneSize(20)
1144
1145         # Make the splitter on the right expand the top window when resized
1146         def SplitterOnSize(evt):
1147             splitter = evt.GetEventObject()
1148             sz = splitter.GetSize()
1149             splitter.SetSashPosition(sz.height - 160, False)
1150             evt.Skip()
1151
1152         splitter2.Bind(wx.EVT_SIZE, SplitterOnSize)
1153
1154         # select initial items
1155         self.nb.SetSelection(0)
1156         self.tree.SelectItem(root)
1157
1158         # Load 'Main' module
1159         self.LoadDemo(self.overviewText)
1160         self.loaded = True
1161
1162         # select some other initial module?
1163         if len(sys.argv) > 1:
1164             arg = sys.argv[1]
1165             if arg.endswith('.py'):
1166                 arg = arg[:-3]
1167             selectedDemo = self.treeMap.get(arg, None)
1168             if selectedDemo:
1169                 self.tree.SelectItem(selectedDemo)
1170                 self.tree.EnsureVisible(selectedDemo)
1171
1172
1173     #---------------------------------------------
1174     def WriteText(self, text):
1175         if text[-1:] == '\n':
1176             text = text[:-1]
1177         wx.LogMessage(text)
1178
1179     def write(self, txt):
1180         self.WriteText(txt)
1181
1182     #---------------------------------------------
1183     def OnItemExpanded(self, event):
1184         item = event.GetItem()
1185         wx.LogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
1186         event.Skip()
1187
1188     #---------------------------------------------
1189     def OnItemCollapsed(self, event):
1190         item = event.GetItem()
1191         wx.LogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
1192         event.Skip()
1193
1194     #---------------------------------------------
1195     def OnTreeLeftDown(self, event):
1196         # reset the overview text if the tree item is clicked on again
1197         pt = event.GetPosition();
1198         item, flags = self.tree.HitTest(pt)
1199         if item == self.tree.GetSelection():
1200             self.SetOverview(self.tree.GetItemText(item)+" Overview", self.curOverview)
1201         event.Skip()
1202
1203     #---------------------------------------------
1204     def OnSelChanged(self, event):
1205         if self.dying or  not self.loaded:
1206             return
1207
1208         item = event.GetItem()
1209         itemText = self.tree.GetItemText(item)
1210         self.LoadDemo(itemText)
1211
1212     #---------------------------------------------
1213     def LoadDemo(self, demoName):
1214         try:
1215             wx.BeginBusyCursor()
1216
1217             os.chdir(self.cwd)
1218             self.ShutdownDemoModule()
1219
1220             if demoName == self.overviewText:
1221                 # User selected the "wxPython Overview" node
1222                 # ie: _this_ module
1223                 # Changing the main window at runtime not yet supported...
1224                 self.demoModules = DemoModules(__name__)
1225                 self.SetOverview(self.overviewText, mainOverview)
1226                 self.LoadDemoSource()
1227                 self.UpdateNotebook(0)
1228             else:
1229                 if os.path.exists(GetOriginalFilename(demoName)):
1230                     wx.LogMessage("Loading demo %s.py..." % demoName)
1231                     self.demoModules = DemoModules(demoName)
1232                     self.LoadDemoSource()
1233                     self.tree.Refresh()
1234                 else:
1235                     self.SetOverview("wxPython", mainOverview)
1236                     self.codePage = None
1237                     self.UpdateNotebook(0)
1238         finally:
1239             wx.EndBusyCursor()
1240
1241     #---------------------------------------------
1242     def LoadDemoSource(self):
1243         self.codePage = None
1244         self.codePage = DemoCodePanel(self.nb, self)
1245         self.codePage.LoadDemo(self.demoModules)
1246
1247     #---------------------------------------------
1248     def RunModule(self):
1249         """Runs the active module"""
1250
1251         module = self.demoModules.GetActive()
1252         self.ShutdownDemoModule()
1253         overviewText = ""
1254
1255         # o If the demo returns a window it is placed in a tab.
1256         # o Otherwise, a placeholder tab is created, informing the user that the
1257         #   demo runs outside the main window, and allowing it to be reloaded.
1258         # o If an error occurs (or has occured before) an error tab is created.
1259
1260         if module is not None:
1261             wx.LogMessage("Running demo module...")
1262             if hasattr(module, "overview"):
1263                 overviewText = module.overview
1264
1265             try:
1266                 self.demoPage = module.runTest(self, self.nb, self)
1267             except:
1268                 self.demoPage = DemoErrorPanel(self.nb, self.codePage,
1269                                                DemoError(sys.exc_info()), self)
1270
1271             assert self.demoPage is not None, "runTest must return a window!"
1272
1273         else:
1274             # There was a previous error in compiling or exec-ing
1275             self.demoPage = DemoErrorPanel(self.nb, self.codePage,
1276                                            self.demoModules.GetErrorInfo(), self)
1277
1278         self.SetOverview(self.demoModules.name + " Overview", overviewText)
1279
1280         if self.firstTime:
1281             # cahnge to the demo page the first time a module is run
1282             self.UpdateNotebook(2)
1283             self.firstTime = False
1284         else:
1285             # otherwise just stay on the same tab in case the user has changed to another one
1286             self.UpdateNotebook()
1287
1288     #---------------------------------------------
1289     def ShutdownDemoModule(self):
1290         if self.demoPage:
1291             # inform the window that it's time to quit if it cares
1292             if hasattr(self.demoPage, "ShutdownDemo"):
1293                 self.demoPage.ShutdownDemo()
1294             wx.YieldIfNeeded() # in case the page has pending events
1295             self.demoPage = None
1296
1297     #---------------------------------------------
1298     def UpdateNotebook(self, select = -1):
1299         nb = self.nb
1300         debug = False
1301
1302         def UpdatePage(page, pageText):
1303             pageExists = False
1304             pagePos = -1
1305             for i in range(nb.GetPageCount()):
1306                 if nb.GetPageText(i) == pageText:
1307                     pageExists = True
1308                     pagePos = i
1309                     break
1310
1311             if page:
1312                 if not pageExists:
1313                     # Add a new page
1314                     nb.AddPage(page, pageText)
1315                     if debug: wx.LogMessage("DBG: ADDED %s" % pageText)
1316                 else:
1317                     if nb.GetPage(pagePos) != page:
1318                         # Reload an existing page
1319                         nb.Freeze()
1320                         nb.DeletePage(pagePos)
1321                         nb.InsertPage(pagePos, page, pageText)
1322                         nb.Thaw()
1323                         if debug: wx.LogMessage("DBG: RELOADED %s" % pageText)
1324                     else:
1325                         # Excellent! No redraw/flicker
1326                         if debug: wx.LogMessage("DBG: SAVED from reloading %s" % pageText)
1327             elif pageExists:
1328                 # Delete a page
1329                 nb.DeletePage(pagePos)
1330                 if debug: wx.LogMessage("DBG: DELETED %s" % pageText)
1331             else:
1332                 if debug: wx.LogMessage("DBG: STILL GONE - %s" % pageText)
1333
1334         if select == -1:
1335             select = nb.GetSelection()
1336
1337         UpdatePage(self.codePage, "Demo Code")
1338         UpdatePage(self.demoPage, "Demo")
1339
1340         if select >= 0 and select < nb.GetPageCount():
1341             nb.SetSelection(select)
1342
1343     #---------------------------------------------
1344     def SetOverview(self, name, text):
1345         self.curOverview = text
1346         lead = text[:6]
1347         if lead != '<html>' and lead != '<HTML>':
1348             text = '<br>'.join(text.split('\n'))
1349         if wx.USE_UNICODE:
1350             text = text.decode('iso8859_1')
1351         self.ovr.SetPage(text)
1352         self.nb.SetPageText(0, name)
1353
1354     #---------------------------------------------
1355     # Menu methods
1356     def OnFileExit(self, *event):
1357         self.Close()
1358
1359     def OnToggleRedirect(self, event):
1360         app = wx.GetApp()
1361         if event.Checked():
1362             app.RedirectStdio()
1363             print "Print statements and other standard output will now be directed to this window."
1364         else:
1365             app.RestoreStdio()
1366             print "Print statements and other standard output will now be sent to the usual location."
1367
1368     def OnHelpAbout(self, event):
1369         from About import MyAboutBox
1370         about = MyAboutBox(self)
1371         about.ShowModal()
1372         about.Destroy()
1373
1374     def OnHelpFind(self, event):
1375         self.nb.SetSelection(1)
1376         self.finddlg = wx.FindReplaceDialog(self, self.finddata, "Find",
1377                         wx.FR_NOUPDOWN |
1378                         wx.FR_NOMATCHCASE |
1379                         wx.FR_NOWHOLEWORD)
1380         self.finddlg.Show(True)
1381
1382     def OnFind(self, event):
1383         editor = self.codePage.editor
1384         self.nb.SetSelection(1)
1385         end = editor.GetLastPosition()
1386         textstring = editor.GetRange(0, end).lower()
1387         start = editor.GetSelection()[1]
1388         findstring = self.finddata.GetFindString().lower()
1389         loc = textstring.find(findstring, start)
1390         if loc == -1 and start != 0:
1391             # string not found, start at beginning
1392             start = 0
1393             loc = textstring.find(findstring, start)
1394         if loc == -1:
1395             dlg = wx.MessageDialog(self, 'Find String Not Found',
1396                           'Find String Not Found in Demo File',
1397                           wx.OK | wx.ICON_INFORMATION)
1398             dlg.ShowModal()
1399             dlg.Destroy()
1400         if self.finddlg:
1401             if loc == -1:
1402                 self.finddlg.SetFocus()
1403                 return
1404             else:
1405                 self.finddlg.Destroy()
1406         editor.ShowPosition(loc)
1407         editor.SetSelection(loc, loc + len(findstring))
1408
1409
1410
1411     def OnFindNext(self, event):
1412         if self.finddata.GetFindString():
1413             self.OnFind(event)
1414         else:
1415             self.OnHelpFind(event)
1416
1417     def OnFindClose(self, event):
1418         event.GetDialog().Destroy()
1419
1420
1421     def OnOpenShellWindow(self, evt):
1422         if self.shell:
1423             # if it already exists then just make sure it's visible
1424             s = self.shell
1425             if s.IsIconized():
1426                 s.Iconize(False)
1427             s.Raise()
1428         else:
1429             # Make a PyShell window
1430             from wx import py
1431             namespace = { 'wx'    : wx,
1432                           'app'   : wx.GetApp(),
1433                           'frame' : self,
1434                           }
1435             self.shell = py.shell.ShellFrame(None, locals=namespace)
1436             self.shell.SetSize((640,480))
1437             self.shell.Show()
1438
1439             # Hook the close event of the main frame window so that we
1440             # close the shell at the same time if it still exists
1441             def CloseShell(evt):
1442                 if self.shell:
1443                     self.shell.Close()
1444                 evt.Skip()
1445             self.Bind(wx.EVT_CLOSE, CloseShell)
1446
1447
1448     #---------------------------------------------
1449     def OnCloseWindow(self, event):
1450         self.dying = True
1451         self.demoPage = None
1452         self.codePage = None
1453         self.mainmenu = None
1454         self.Destroy()
1455
1456
1457     #---------------------------------------------
1458     def OnIdle(self, event):
1459         if self.otherWin:
1460             self.otherWin.Raise()
1461             self.demoPage = self.otherWin
1462             self.otherWin = None
1463
1464
1465     #---------------------------------------------
1466     def ShowTip(self):
1467         try:
1468             showTipText = open(opj("data/showTips")).read()
1469             showTip, index = eval(showTipText)
1470         except IOError:
1471             showTip, index = (1, 0)
1472         if showTip:
1473             tp = wx.CreateFileTipProvider(opj("data/tips.txt"), index)
1474             ##tp = MyTP(0)
1475             showTip = wx.ShowTip(self, tp)
1476             index = tp.GetCurrentTip()
1477             open(opj("data/showTips"), "w").write(str( (showTip, index) ))
1478
1479
1480     #---------------------------------------------
1481     def OnDemoMenu(self, event):
1482         try:
1483             selectedDemo = self.treeMap[self.mainmenu.GetLabel(event.GetId())]
1484         except:
1485             selectedDemo = None
1486         if selectedDemo:
1487             self.tree.SelectItem(selectedDemo)
1488             self.tree.EnsureVisible(selectedDemo)
1489
1490
1491     #---------------------------------------------
1492     def OnTaskBarActivate(self, evt):
1493         if self.IsIconized():
1494             self.Iconize(False)
1495         if not self.IsShown():
1496             self.Show(True)
1497         self.Raise()
1498
1499     #---------------------------------------------
1500
1501     TBMENU_RESTORE = 1000
1502     TBMENU_CLOSE   = 1001
1503
1504     def OnTaskBarMenu(self, evt):
1505         menu = wx.Menu()
1506         menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
1507         menu.Append(self.TBMENU_CLOSE,   "Close")
1508         self.tbicon.PopupMenu(menu)
1509         menu.Destroy()
1510
1511     #---------------------------------------------
1512     def OnTaskBarClose(self, evt):
1513         self.Close()
1514
1515         # because of the way wx.TaskBarIcon.PopupMenu is implemented we have to
1516         # prod the main idle handler a bit to get the window to actually close
1517         wx.GetApp().ProcessIdle()
1518
1519
1520     #---------------------------------------------
1521     def OnIconfiy(self, evt):
1522         wx.LogMessage("OnIconfiy: %d" % evt.Iconized())
1523         evt.Skip()
1524
1525     #---------------------------------------------
1526     def OnMaximize(self, evt):
1527         wx.LogMessage("OnMaximize")
1528         evt.Skip()
1529
1530
1531
1532
1533 #---------------------------------------------------------------------------
1534 #---------------------------------------------------------------------------
1535
1536 class MySplashScreen(wx.SplashScreen):
1537     def __init__(self):
1538         bmp = wx.Image(opj("bitmaps/splash.gif")).ConvertToBitmap()
1539         wx.SplashScreen.__init__(self, bmp,
1540                                  wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT,
1541                                  3000, None, -1)
1542         self.Bind(wx.EVT_CLOSE, self.OnClose)
1543
1544     def OnClose(self, evt):
1545         self.Hide()
1546         frame = wxPythonDemo(None, "wxPython: (A Demonstration)")
1547         frame.Show()
1548         evt.Skip()  # Make sure the default handler runs too...
1549
1550
1551 class MyApp(wx.App):
1552     def OnInit(self):
1553         """
1554         Create and show the splash screen.  It will then create and show
1555         the main frame when it is time to do so.
1556         """
1557
1558         # For debugging
1559         #self.SetAssertMode(wx.PYAPP_ASSERT_DIALOG)
1560
1561         # Normally when using a SplashScreen you would create it, show
1562         # it and then continue on with the applicaiton's
1563         # initialization, finally creating and showing the main
1564         # application window(s).  In this case we have nothing else to
1565         # do so we'll delay showing the main frame until later (see
1566         # OnClose above) so the users can see the SplashScreen effect.
1567         splash = MySplashScreen()
1568         splash.Show()
1569
1570         return True
1571
1572
1573
1574 #---------------------------------------------------------------------------
1575
1576 def main():
1577     try:
1578         demoPath = os.path.dirname(__file__)
1579         os.chdir(demoPath)
1580     except:
1581         pass
1582     app = MyApp(False)
1583     app.MainLoop()
1584
1585 #---------------------------------------------------------------------------
1586
1587
1588 mainOverview = """<html><body>
1589 <h2>wxPython</h2>
1590
1591 <p> wxPython is a <b>GUI toolkit</b> for the Python programming
1592 language.  It allows Python programmers to create programs with a
1593 robust, highly functional graphical user interface, simply and easily.
1594 It is implemented as a Python extension module (native code) that
1595 wraps the popular wxWindows cross platform GUI library, which is
1596 written in C++.
1597
1598 <p> Like Python and wxWindows, wxPython is <b>Open Source</b> which
1599 means that it is free for anyone to use and the source code is
1600 available for anyone to look at and modify.  Or anyone can contribute
1601 fixes or enhancements to the project.
1602
1603 <p> wxPython is a <b>cross-platform</b> toolkit.  This means that the
1604 same program will run on multiple platforms without modification.
1605 Currently supported platforms are 32-bit Microsoft Windows, most Unix
1606 or unix-like systems, and Macintosh OS X. Since the language is
1607 Python, wxPython programs are <b>simple, easy</b> to write and easy to
1608 understand.
1609
1610 <p> <b>This demo</b> is not only a collection of test cases for
1611 wxPython, but is also designed to help you learn about and how to use
1612 wxPython.  Each sample is listed in the tree control on the left.
1613 When a sample is selected in the tree then a module is loaded and run
1614 (usually in a tab of this notebook,) and the source code of the module
1615 is loaded in another tab for you to browse and learn from.
1616
1617 """
1618
1619
1620 #----------------------------------------------------------------------------
1621 #----------------------------------------------------------------------------
1622
1623 if __name__ == '__main__':
1624     __name__ = 'Main'
1625     main()
1626
1627 #----------------------------------------------------------------------------
1628
1629
1630
1631
1632
1633
1634