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