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, style=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 =
 447                                  wx.TE_MULTILINE | 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, size=(1,1))
 486         if 'wxMSW' in wx.PlatformInfo:
 487             self.Hide()
 488         self.mainFrame = mainFrame
 489         self.editor = DemoCodeEditor(self)
 490         self.editor.RegisterModifiedEvent(self.OnCodeModified)
 491
 492         self.btnSave = wx.Button(self, -1, "Save Changes")
 493         self.btnRestore = wx.Button(self, -1, "Delete Modified")
 494         self.btnSave.Enable(False)
 495         self.btnSave.Bind(wx.EVT_BUTTON, self.OnSave)
 496         self.btnRestore.Bind(wx.EVT_BUTTON, self.OnRestore)
 497
 498         self.radioButtons = { modOriginal: wx.RadioButton(self, -1, "Original", style = wx.RB_GROUP),
 499                               modModified: wx.RadioButton(self, -1, "Modified") }
 500
 501         self.controlBox = wx.BoxSizer(wx.HORIZONTAL)
 502         self.controlBox.Add(wx.StaticText(self, -1, "Active Version:"), 0,
 503                             wx.RIGHT | wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 5)
 504         for modID, radioButton in self.radioButtons.items():
 505             self.controlBox.Add(radioButton, 0, wx.EXPAND | wx.RIGHT, 5)
 506             radioButton.modID = modID # makes it easier for the event handler
 507             radioButton.Bind(wx.EVT_RADIOBUTTON, self.OnRadioButton)
 508
 509         self.controlBox.Add(self.btnSave, 0, wx.RIGHT, 5)
 510         self.controlBox.Add(self.btnRestore, 0)
 511
 512         self.box = wx.BoxSizer(wx.VERTICAL)
 513         self.box.Add(self.controlBox, 0, wx.EXPAND)
 514         self.box.Add(wx.StaticLine(self), 0, wx.EXPAND)
 515         self.box.Add(self.editor, 1, wx.EXPAND)
 516
 517         self.box.Fit(self)
 518         self.SetSizer(self.box)
 519
 520
 521     # Loads a demo from a DemoModules object
 522     def LoadDemo(self, demoModules):
 523         self.demoModules = demoModules
 524         if (modDefault == modModified) and demoModules.Exists(modModified):
 525             demoModules.SetActive(modModified)
 526         else:
 527             demoModules.SetActive(modOriginal)
 528         self.radioButtons[demoModules.GetActiveID()].Enable(True)
 529         self.ActiveModuleChanged()
 530
 531
 532     def ActiveModuleChanged(self):
 533         self.LoadDemoSource(self.demoModules.GetSource())
 534         self.UpdateControlState()
 535         self.ReloadDemo()
 536
 537
 538     def LoadDemoSource(self, source):
 539         self.editor.Clear()
 540         self.editor.SetValue(source)
 541         self.JumpToLine(0)
 542         self.btnSave.Enable(False)
 543
 544
 545     def JumpToLine(self, line, highlight=False):
 546         self.editor.GotoLine(line)
 547         self.editor.SetFocus()
 548         if highlight:
 549             self.editor.SelectLine(line)
 550
 551
 552     def UpdateControlState(self):
 553         active = self.demoModules.GetActiveID()
 554         # Update the radio/restore buttons
 555         for moduleID in self.radioButtons:
 556             btn = self.radioButtons[moduleID]
 557             if moduleID == active:
 558                 btn.SetValue(True)
 559             else:
 560                 btn.SetValue(False)
 561
 562             if self.demoModules.Exists(moduleID):
 563                 btn.Enable(True)
 564                 if moduleID == modModified:
 565                     self.btnRestore.Enable(True)
 566             else:
 567                 btn.Enable(False)
 568                 if moduleID == modModified:
 569                     self.btnRestore.Enable(False)
 570
 571
 572     def OnRadioButton(self, event):
 573         radioSelected = event.GetEventObject()
 574         modSelected = radioSelected.modID
 575         if modSelected != self.demoModules.GetActiveID():
 576             busy = wx.BusyInfo("Reloading demo module...")
 577             self.demoModules.SetActive(modSelected)
 578             self.ActiveModuleChanged()
 579
 580
 581     def ReloadDemo(self):
 582         if self.demoModules.name != __name__:
 583             self.mainFrame.RunModule()
 584
 585
 586     def OnCodeModified(self, event):
 587         self.btnSave.Enable(self.editor.IsModified())
 588
 589
 590     def OnSave(self, event):
 591         if self.demoModules.Exists(modModified):
 592             if self.demoModules.GetActiveID() == modOriginal:
 593                 overwriteMsg = "You are about to overwrite an already existing modified copy\n" + \
 594                                "Do you want to continue?"
 595                 dlg = wx.MessageDialog(self, overwriteMsg, "wxPython Demo",
 596                                        wx.YES_NO | wx.NO_DEFAULT| wx.ICON_EXCLAMATION)
 597                 result = dlg.ShowModal()
 598                 if result == wx.ID_NO:
 599                     return
 600                 dlg.Destroy()
 601
 602         self.demoModules.SetActive(modModified)
 603         modifiedFilename = GetModifiedFilename(self.demoModules.name)
 604
 605         # Create the demo directory if one doesn't already exist
 606         if not os.path.exists(GetModifiedDirectory()):
 607             try:
 608                 os.makedirs(GetModifiedDirectory())
 609                 if not os.path.exists(GetModifiedDirectory()):
 610                     wx.LogMessage("BUG: Created demo directory but it still doesn't exit")
 611                     raise AssetionError
 612             except:
 613                 wx.LogMessage("Error creating demo directory: %s" % GetModifiedDirectory())
 614                 return
 615             else:
 616                 wx.LogMessage("Created directory for modified demos: %s" % GetModifiedDirectory())
 617
 618         # Save
 619         f = open(modifiedFilename, "wt")
 620         source = self.editor.GetText()
 621         try:
 622             f.write(source)
 623         finally:
 624             f.close()
 625
 626         busy = wx.BusyInfo("Reloading demo module...")
 627         self.demoModules.LoadFromFile(modModified, modifiedFilename)
 628         self.ActiveModuleChanged()
 629
 630
 631     def OnRestore(self, event): # Handles the "Delete Modified" button
 632         modifiedFilename = GetModifiedFilename(self.demoModules.name)
 633         self.demoModules.Delete(modModified)
 634         os.unlink(modifiedFilename) # Delete the modified copy
 635         busy = wx.BusyInfo("Reloading demo module...")
 636         self.ActiveModuleChanged()
 637
 638
 639 #---------------------------------------------------------------------------
 640
 641 def opj(path):
 642     """Convert paths to the platform-specific separator"""
 643     str = apply(os.path.join, tuple(path.split('/')))
 644     # HACK: on Linux, a leading / gets lost...
 645     if path.startswith('/'):
 646         str = '/' + str
 647     return str
 648
 649
 650 def GetModifiedDirectory():
 651     """
 652     Returns the directory where modified versions of the demo files
 653     are stored
 654     """
 655     return opj(wx.GetHomeDir() + "/.wxPyDemo/modified/")
 656
 657
 658 def GetModifiedFilename(name):
 659     """
 660     Returns the filename of the modified version of the specified demo
 661     """
 662     if not name.endswith(".py"):
 663         name = name + ".py"
 664     return GetModifiedDirectory() + name
 665
 666
 667 def GetOriginalFilename(name):
 668     """
 669     Returns the filename of the original version of the specified demo
 670     """
 671     if not name.endswith(".py"):
 672         name = name + ".py"
 673     return name
 674
 675
 676 def DoesModifiedExist(name):
 677     """Returns whether the specified demo has a modified copy"""
 678     if os.path.exists(GetModifiedFilename(name)):
 679         return True
 680     else:
 681         return False
 682
 683
 684 #---------------------------------------------------------------------------
 685
 686 class ModuleDictWrapper:
 687     """Emulates a module with a dynamically compiled __dict__"""
 688     def __init__(self, dict):
 689         self.dict = dict
 690
 691     def __getattr__(self, name):
 692         if name in self.dict:
 693             return self.dict[name]
 694         else:
 695             raise AttributeError
 696
 697 class DemoModules:
 698     """
 699     Dynamically manages the original/modified versions of a demo
 700     module
 701     """
 702     def __init__(self, name):
 703         self.modActive = -1
 704         self.name = name
 705
 706         #              (dict , source ,  filename , description   , error information )
 707         #              (  0  ,   1    ,     2     ,      3        ,          4        )
 708         self.modules = [[None,  ""    ,    ""     , "<original>"  ,        None],
 709                         [None,  ""    ,    ""     , "<modified>"  ,        None]]
 710
 711         # load original module
 712         self.LoadFromFile(modOriginal, GetOriginalFilename(name))
 713         self.SetActive(modOriginal)
 714
 715         # load modified module (if one exists)
 716         if DoesModifiedExist(name):
 717            self.LoadFromFile(modModified, GetModifiedFilename(name))
 718
 719
 720     def LoadFromFile(self, modID, filename):
 721         self.modules[modID][2] = filename
 722         file = open(filename, "rt")
 723         self.LoadFromSource(modID, file.read())
 724         file.close()
 725
 726
 727     def LoadFromSource(self, modID, source):
 728         self.modules[modID][1] = source
 729         self.LoadDict(modID)
 730
 731
 732     def LoadDict(self, modID):
 733         if self.name != __name__:
 734             source = self.modules[modID][1]
 735             description = self.modules[modID][3]
 736
 737             try:
 738                 self.modules[modID][0] = {}
 739                 code = compile(source, description, "exec")
 740                 exec code in self.modules[modID][0]
 741             except:
 742                 self.modules[modID][4] = DemoError(sys.exc_info())
 743                 self.modules[modID][0] = None
 744             else:
 745                 self.modules[modID][4] = None
 746
 747
 748     def SetActive(self, modID):
 749         if modID != modOriginal and modID != modModified:
 750             raise LookupError
 751         else:
 752             self.modActive = modID
 753
 754
 755     def GetActive(self):
 756         dict = self.modules[self.modActive][0]
 757         if dict is None:
 758             return None
 759         else:
 760             return ModuleDictWrapper(dict)
 761
 762
 763     def GetActiveID(self):
 764         return self.modActive
 765
 766
 767     def GetSource(self, modID = None):
 768         if modID is None:
 769             modID = self.modActive
 770         return self.modules[modID][1]
 771
 772
 773     def GetFilename(self, modID = None):
 774         if modID is None:
 775             modID = self.modActive
 776         return self.modules[self.modActive][2]
 777
 778
 779     def GetErrorInfo(self, modID = None):
 780         if modID is None:
 781             modID = self.modActive
 782         return self.modules[self.modActive][4]
 783
 784
 785     def Exists(self, modID):
 786         return self.modules[modID][1] != ""
 787
 788
 789     def UpdateFile(self, modID = None):
 790         """Updates the file from which a module was loaded
 791         with (possibly updated) source"""
 792         if modID is None:
 793             modID = self.modActive
 794
 795         source = self.modules[modID][1]
 796         filename = self.modules[modID][2]
 797
 798         try:
 799             file = open(filename, "wt")
 800             file.write(source)
 801         finally:
 802             file.close()
 803
 804
 805     def Delete(self, modID):
 806         if self.modActive == modID:
 807             self.SetActive(0)
 808
 809         self.modules[modID][0] = None
 810         self.modules[modID][1] = ""
 811         self.modules[modID][2] = ""
 812
 813
 814 #---------------------------------------------------------------------------
 815
 816 class DemoError:
 817     """Wraps and stores information about the current exception"""
 818     def __init__(self, exc_info):
 819         import copy
 820
 821         excType, excValue = exc_info[:2]
 822         # traceback list entries: (filename, line number, function name, text)
 823         self.traceback = traceback.extract_tb(exc_info[2])
 824
 825         # --Based on traceback.py::format_exception_only()--
 826         if type(excType) == types.ClassType:
 827             self.exception_type = excType.__name__
 828         else:
 829             self.exception_type = excType
 830
 831         # If it's a syntax error, extra information needs
 832         # to be added to the traceback
 833         if excType is SyntaxError:
 834             try:
 835                 msg, (filename, lineno, self.offset, line) = excValue
 836             except:
 837                 pass
 838             else:
 839                 if not filename:
 840                     filename = "<string>"
 841                 line = line.strip()
 842                 self.traceback.append( (filename, lineno, "", line) )
 843                 excValue = msg
 844         try:
 845             self.exception_details = str(excValue)
 846         except:
 847             self.exception_details = "<unprintable %s object>" & type(excValue).__name__
 848
 849         del exc_info
 850
 851     def __str__(self):
 852         ret = "Type %s \n \
 853         Traceback: %s \n \
 854         Details  : %s" % ( str(self.exception_type), str(self.traceback), self.exception_details )
 855         return ret
 856
 857 #---------------------------------------------------------------------------
 858
 859 class DemoErrorPanel(wx.Panel):
 860     """Panel put into the demo tab when the demo fails to run due  to errors"""
 861
 862     def __init__(self, parent, codePanel, demoError, log):
 863         wx.Panel.__init__(self, parent, -1)#, style=wx.NO_FULL_REPAINT_ON_RESIZE)
 864         self.codePanel = codePanel
 865         self.nb = parent
 866         self.log = log
 867
 868         self.box = wx.BoxSizer(wx.VERTICAL)
 869
 870         # Main Label
 871         self.box.Add(wx.StaticText(self, -1, "An error has occured while trying to run the demo")
 872                      , 0, wx.ALIGN_CENTER | wx.TOP, 10)
 873
 874         # Exception Information
 875         boxInfo      = wx.StaticBox(self, -1, "Exception Info" )
 876         boxInfoSizer = wx.StaticBoxSizer(boxInfo, wx.VERTICAL ) # Used to center the grid within the box
 877         boxInfoGrid  = wx.FlexGridSizer(0, 2, 0, 0)
 878         textFlags    = wx.ALIGN_RIGHT | wx.LEFT | wx.RIGHT | wx.TOP
 879         boxInfoGrid.Add(wx.StaticText(self, -1, "Type: "), 0, textFlags, 5 )
 880         boxInfoGrid.Add(wx.StaticText(self, -1, demoError.exception_type) , 0, textFlags, 5 )
 881         boxInfoGrid.Add(wx.StaticText(self, -1, "Details: ") , 0, textFlags, 5 )
 882         boxInfoGrid.Add(wx.StaticText(self, -1, demoError.exception_details) , 0, textFlags, 5 )
 883         boxInfoSizer.Add(boxInfoGrid, 0, wx.ALIGN_CENTRE | wx.ALL, 5 )
 884         self.box.Add(boxInfoSizer, 0, wx.ALIGN_CENTER | wx.ALL, 5)
 885
 886         # Set up the traceback list
 887         # This one automatically resizes last column to take up remaining space
 888         from ListCtrl import TestListCtrl
 889         self.list = TestListCtrl(self, -1, style=wx.LC_REPORT  | wx.SUNKEN_BORDER)
 890         self.list.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
 891         self.list.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected)
 892         self.list.InsertColumn(0, "Filename")
 893         self.list.InsertColumn(1, "Line", wx.LIST_FORMAT_RIGHT)
 894         self.list.InsertColumn(2, "Function")
 895         self.list.InsertColumn(3, "Code")
 896         self.InsertTraceback(self.list, demoError.traceback)
 897         self.list.SetColumnWidth(0, wx.LIST_AUTOSIZE)
 898         self.list.SetColumnWidth(2, wx.LIST_AUTOSIZE)
 899         self.box.Add(wx.StaticText(self, -1, "Traceback:")
 900                      , 0, wx.ALIGN_CENTER | wx.TOP, 5)
 901         self.box.Add(self.list, 1, wx.GROW | wx.ALIGN_CENTER | wx.ALL, 5)
 902         self.box.Add(wx.StaticText(self, -1, "Entries from the demo module are shown in blue\n"
 903                                            + "Double-click on them to go to the offending line")
 904                      , 0, wx.ALIGN_CENTER | wx.BOTTOM, 5)
 905
 906         self.box.Fit(self)
 907         self.SetSizer(self.box)
 908
 909
 910     def InsertTraceback(self, list, traceback):
 911         #Add the traceback data
 912         for x in range(len(traceback)):
 913             data = traceback[x]
 914             list.InsertStringItem(x, os.path.basename(data[0])) # Filename
 915             list.SetStringItem(x, 1, str(data[1]))              # Line
 916             list.SetStringItem(x, 2, str(data[2]))              # Function
 917             list.SetStringItem(x, 3, str(data[3]))              # Code
 918
 919             # Check whether this entry is from the demo module
 920             if data[0] == "<original>" or data[0] == "<modified>": # FIXME: make more generalised
 921                 self.list.SetItemData(x, int(data[1]))   # Store line number for easy access
 922                 # Give it a blue colour
 923                 item = self.list.GetItem(x)
 924                 item.SetTextColour(wx.BLUE)
 925                 self.list.SetItem(item)
 926             else:
 927                 self.list.SetItemData(x, -1)        # Editor can't jump into this one's code
 928
 929
 930     def OnItemSelected(self, event):
 931         # This occurs before OnDoubleClick and can be used to set the
 932         # currentItem. OnDoubleClick doesn't get a wxListEvent....
 933         self.currentItem = event.m_itemIndex
 934         event.Skip()
 935
 936
 937     def OnDoubleClick(self, event):
 938         # If double-clicking on a demo's entry, jump to the line number
 939         line = self.list.GetItemData(self.currentItem)
 940         if line != -1:
 941             self.nb.SetSelection(1) # Switch to the code viewer tab
 942             wx.CallAfter(self.codePanel.JumpToLine, line-1, True)
 943         event.Skip()
 944
 945
 946 #---------------------------------------------------------------------------
 947
 948 class wxPythonDemo(wx.Frame):
 949     overviewText = "wxPython Overview"
 950
 951     def __init__(self, parent, title):
 952         wx.Frame.__init__(self, parent, -1, title, size = (950, 720),
 953                           style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
 954
 955         self.loaded = False
 956         self.cwd = os.getcwd()
 957         self.curOverview = ""
 958         self.demoPage = None
 959         self.codePage = None
 960         self.shell = None
 961         self.firstTime = True
 962
 963         icon = images.getMondrianIcon()
 964         self.SetIcon(icon)
 965
 966         if wx.Platform != '__WXMAC__':
 967             # setup a taskbar icon, and catch some events from it
 968             dim = 16  # (may want to use 22 on wxGTK, but 16 looks okay too)
 969             icon = wx.IconFromBitmap(
 970                 images.getMondrianImage().Scale(dim,dim).ConvertToBitmap() )
 971             #icon = wx.Icon('bmp_source/mondrian.ico', wx.BITMAP_TYPE_ICO)
 972             #icon = images.getMondrianIcon()
 973             self.tbicon = wx.TaskBarIcon()
 974             self.tbicon.SetIcon(icon, "wxPython Demo")
 975             self.tbicon.Bind(wx.EVT_TASKBAR_LEFT_DCLICK, self.OnTaskBarActivate)
 976             self.tbicon.Bind(wx.EVT_TASKBAR_RIGHT_UP, self.OnTaskBarMenu)
 977             self.tbicon.Bind(wx.EVT_MENU, self.OnTaskBarActivate, id=self.TBMENU_RESTORE)
 978             self.tbicon.Bind(wx.EVT_MENU, self.OnTaskBarClose, id=self.TBMENU_CLOSE)
 979
 980         wx.CallAfter(self.ShowTip)
 981
 982         self.otherWin = None
 983         self.Bind(wx.EVT_IDLE, self.OnIdle)
 984         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 985         self.Bind(wx.EVT_ICONIZE, self.OnIconfiy)
 986         self.Bind(wx.EVT_MAXIMIZE, self.OnMaximize)
 987
 988         self.Centre(wx.BOTH)
 989         self.CreateStatusBar(1, wx.ST_SIZEGRIP)
 990
 991         splitter = wx.SplitterWindow(self, -1, style=wx.CLIP_CHILDREN | wx.SP_LIVE_UPDATE | wx.SP_3D)
 992         splitter2 = wx.SplitterWindow(splitter, -1, style=wx.CLIP_CHILDREN | wx.SP_LIVE_UPDATE | wx.SP_3D)
 993
 994         def EmptyHandler(evt): pass
 995         #splitter.Bind(wx.EVT_ERASE_BACKGROUND, EmptyHandler)
 996         #splitter2.Bind(wx.EVT_ERASE_BACKGROUND, EmptyHandler)
 997
 998         # Prevent TreeCtrl from displaying all items after destruction when True
 999         self.dying = False
1000
1001         # Create a Notebook
1002         self.nb = wx.Notebook(splitter2, -1, style=wx.CLIP_CHILDREN)
1003
1004         # Make a File menu
1005         self.mainmenu = wx.MenuBar()
1006         menu = wx.Menu()
1007         item = menu.Append(-1, '&Redirect Output',
1008                            'Redirect print statements to a window',
1009                            wx.ITEM_CHECK)
1010         self.Bind(wx.EVT_MENU, self.OnToggleRedirect, item)
1011
1012         item = menu.Append(-1, 'E&xit\tAlt-X', 'Get the heck outta here!')
1013         self.Bind(wx.EVT_MENU, self.OnFileExit, item)
1014         wx.App_SetMacExitMenuItemId(item.GetId())
1015         self.mainmenu.Append(menu, '&File')
1016
1017         # Make a Demo menu
1018         menu = wx.Menu()
1019         for item in _treeList:
1020             submenu = wx.Menu()
1021             for childItem in item[1]:
1022                 mi = submenu.Append(-1, childItem)
1023                 self.Bind(wx.EVT_MENU, self.OnDemoMenu, mi)
1024             menu.AppendMenu(wx.NewId(), item[0], submenu)
1025         self.mainmenu.Append(menu, '&Demo')
1026
1027         # Make a Demo Code menu
1028         #TODO: Add new menu items
1029         #       Like the option-enabled entries to select the
1030         #       active module
1031         #TODO: should we bother?
1032
1033         #menu = wx.Menu()
1034         #saveID = wx.NewId()
1035         #restoreID = wx.NewId()
1036        #
1037         #menu.Append(saveID, '&Save\tCtrl-S', 'Save edited demo')
1038         #menu.Append(restoreID, '&Delete Modified\tCtrl-R', 'Delete modified copy')
1039         #self.Bind(wx.EVT_MENU, self.codePage.OnSave, id=saveID)
1040         #self.Bind(wx.EVT_MENU, self.codePage.OnRestore, id=restoreID)
1041         #self.mainmenu.Append(menu, 'Demo &Code')
1042        #
1043
1044         # Make a Help menu
1045         menu = wx.Menu()
1046         findItem = menu.Append(-1, '&Find\tCtrl-F', 'Find in the Demo Code')
1047         findnextItem = menu.Append(-1, 'Find &Next\tF3', 'Find Next')
1048         menu.AppendSeparator()
1049
1050         shellItem = menu.Append(-1, 'Open Py&Shell Window\tF5',
1051                                 'An interactive interpreter window with the demo app and frame objects in the namesapce')
1052         menu.AppendSeparator()
1053         helpItem = menu.Append(-1, '&About\tCtrl-H', 'wxPython RULES!!!')
1054         wx.App_SetMacAboutMenuItemId(helpItem.GetId())
1055
1056         self.Bind(wx.EVT_MENU, self.OnOpenShellWindow, shellItem)
1057         self.Bind(wx.EVT_MENU, self.OnHelpAbout, helpItem)
1058         self.Bind(wx.EVT_MENU, self.OnHelpFind,  findItem)
1059         self.Bind(wx.EVT_MENU, self.OnFindNext,  findnextItem)
1060         self.Bind(wx.EVT_COMMAND_FIND, self.OnFind)
1061         self.Bind(wx.EVT_COMMAND_FIND_NEXT, self.OnFind)
1062         self.Bind(wx.EVT_COMMAND_FIND_CLOSE, self.OnFindClose)
1063         self.mainmenu.Append(menu, '&Help')
1064         self.SetMenuBar(self.mainmenu)
1065
1066         self.finddata = wx.FindReplaceData()
1067
1068         if 0:
1069             # This is another way to set Accelerators, in addition to
1070             # using the '\t<key>' syntax in the menu items.
1071             aTable = wx.AcceleratorTable([(wx.ACCEL_ALT,  ord('X'), exitID),
1072                                           (wx.ACCEL_CTRL, ord('H'), helpID),
1073                                           (wx.ACCEL_CTRL, ord('F'), findID),
1074                                           (wx.ACCEL_NORMAL, WXK_F3, findnextID)
1075                                           ])
1076             self.SetAcceleratorTable(aTable)
1077
1078
1079         # Create a TreeCtrl
1080         tID = wx.NewId()
1081         self.treeMap = {}
1082         self.tree = wx.TreeCtrl(splitter, tID, style =
1083                                 wx.TR_DEFAULT_STYLE #| wx.TR_HAS_VARIABLE_ROW_HEIGHT
1084                                )
1085
1086         root = self.tree.AddRoot("wxPython Overview")
1087         firstChild = None
1088         for item in _treeList:
1089             child = self.tree.AppendItem(root, item[0])
1090             if not firstChild: firstChild = child
1091             for childItem in item[1]:
1092                 theDemo = self.tree.AppendItem(child, childItem)
1093                 self.treeMap[childItem] = theDemo
1094
1095         self.tree.Expand(root)
1096         self.tree.Expand(firstChild)
1097         self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded, id=tID)
1098         self.tree.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, id=tID)
1099         self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, id=tID)
1100         self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)
1101
1102         # Set up a wx.html.HtmlWindow on the Overview Notebook page
1103         # we put it in a panel first because there seems to be a
1104         # refresh bug of some sort (wxGTK) when it is directly in
1105         # the notebook...
1106         if 0:  # the old way
1107             self.ovr = wx.html.HtmlWindow(self.nb, -1, size=(400, 400))
1108             self.nb.AddPage(self.ovr, self.overviewText)
1109
1110         else:  # hopefully I can remove this hacky code soon, see SF bug #216861
1111             panel = wx.Panel(self.nb, -1, style=wx.CLIP_CHILDREN)
1112             self.ovr = wx.html.HtmlWindow(panel, -1, size=(400, 400))
1113             self.nb.AddPage(panel, self.overviewText)
1114
1115             def OnOvrSize(evt, ovr=self.ovr):
1116                 ovr.SetSize(evt.GetSize())
1117             panel.Bind(wx.EVT_SIZE, OnOvrSize)
1118             panel.Bind(wx.EVT_ERASE_BACKGROUND, EmptyHandler)
1119
1120         if "gtk2" in wx.PlatformInfo:
1121             self.ovr.NormalizeFontSizes()
1122         self.SetOverview(self.overviewText, mainOverview)
1123
1124
1125         # Set up a log window
1126         self.log = wx.TextCtrl(splitter2, -1,
1127                               style = wx.TE_MULTILINE|wx.TE_READONLY|wx.HSCROLL)
1128
1129         # Set the wxWindows log target to be this textctrl
1130         #wx.Log_SetActiveTarget(wx.LogTextCtrl(self.log))
1131
1132         # But instead of the above we want to show how to use our own wx.Log class
1133         wx.Log_SetActiveTarget(MyLog(self.log))
1134
1135         # for serious debugging
1136         #wx.Log_SetActiveTarget(wx.LogStderr())
1137         #wx.Log_SetTraceMask(wx.TraceMessages)
1138
1139
1140         # add the windows to the splitter and split it.
1141         splitter2.SplitHorizontally(self.nb, self.log, -160)
1142         splitter.SplitVertically(self.tree, splitter2, 200)
1143
1144         splitter.SetMinimumPaneSize(20)
1145         splitter2.SetMinimumPaneSize(20)
1146
1147         # Make the splitter on the right expand the top window when resized
1148         def SplitterOnSize(evt):
1149             splitter = evt.GetEventObject()
1150             sz = splitter.GetSize()
1151             splitter.SetSashPosition(sz.height - 160, False)
1152             evt.Skip()
1153
1154         splitter2.Bind(wx.EVT_SIZE, SplitterOnSize)
1155
1156         # select initial items
1157         self.nb.SetSelection(0)
1158         self.tree.SelectItem(root)
1159
1160         # Load 'Main' module
1161         self.LoadDemo(self.overviewText)
1162         self.loaded = True
1163
1164         # select some other initial module?
1165         if len(sys.argv) > 1:
1166             arg = sys.argv[1]
1167             if arg.endswith('.py'):
1168                 arg = arg[:-3]
1169             selectedDemo = self.treeMap.get(arg, None)
1170             if selectedDemo:
1171                 self.tree.SelectItem(selectedDemo)
1172                 self.tree.EnsureVisible(selectedDemo)
1173
1174
1175     #---------------------------------------------
1176     def WriteText(self, text):
1177         if text[-1:] == '\n':
1178             text = text[:-1]
1179         wx.LogMessage(text)
1180
1181     def write(self, txt):
1182         self.WriteText(txt)
1183
1184     #---------------------------------------------
1185     def OnItemExpanded(self, event):
1186         item = event.GetItem()
1187         wx.LogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
1188         event.Skip()
1189
1190     #---------------------------------------------
1191     def OnItemCollapsed(self, event):
1192         item = event.GetItem()
1193         wx.LogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
1194         event.Skip()
1195
1196     #---------------------------------------------
1197     def OnTreeLeftDown(self, event):
1198         # reset the overview text if the tree item is clicked on again
1199         pt = event.GetPosition();
1200         item, flags = self.tree.HitTest(pt)
1201         if item == self.tree.GetSelection():
1202             self.SetOverview(self.tree.GetItemText(item)+" Overview", self.curOverview)
1203         event.Skip()
1204
1205     #---------------------------------------------
1206     def OnSelChanged(self, event):
1207         if self.dying or  not self.loaded:
1208             return
1209
1210         item = event.GetItem()
1211         itemText = self.tree.GetItemText(item)
1212         self.LoadDemo(itemText)
1213
1214     #---------------------------------------------
1215     def LoadDemo(self, demoName):
1216         try:
1217             wx.BeginBusyCursor()
1218
1219             os.chdir(self.cwd)
1220             self.ShutdownDemoModule()
1221
1222             if demoName == self.overviewText:
1223                 # User selected the "wxPython Overview" node
1224                 # ie: _this_ module
1225                 # Changing the main window at runtime not yet supported...
1226                 self.demoModules = DemoModules(__name__)
1227                 self.SetOverview(self.overviewText, mainOverview)
1228                 self.LoadDemoSource()
1229                 self.UpdateNotebook(0)
1230             else:
1231                 if os.path.exists(GetOriginalFilename(demoName)):
1232                     wx.LogMessage("Loading demo %s.py..." % demoName)
1233                     self.demoModules = DemoModules(demoName)
1234                     self.LoadDemoSource()
1235                     self.tree.Refresh()
1236                 else:
1237                     self.SetOverview("wxPython", mainOverview)
1238                     self.codePage = None
1239                     self.UpdateNotebook(0)
1240         finally:
1241             wx.EndBusyCursor()
1242
1243     #---------------------------------------------
1244     def LoadDemoSource(self):
1245         self.codePage = None
1246         self.codePage = DemoCodePanel(self.nb, self)
1247         self.codePage.LoadDemo(self.demoModules)
1248
1249     #---------------------------------------------
1250     def RunModule(self):
1251         """Runs the active module"""
1252
1253         module = self.demoModules.GetActive()
1254         self.ShutdownDemoModule()
1255         overviewText = ""
1256
1257         # o If the demo returns a window it is placed in a tab.
1258         # o Otherwise, a placeholder tab is created, informing the user that the
1259         #   demo runs outside the main window, and allowing it to be reloaded.
1260         # o If an error occurs (or has occured before) an error tab is created.
1261
1262         if module is not None:
1263             wx.LogMessage("Running demo module...")
1264             if hasattr(module, "overview"):
1265                 overviewText = module.overview
1266
1267             try:
1268                 self.demoPage = module.runTest(self, self.nb, self)
1269             except:
1270                 self.demoPage = DemoErrorPanel(self.nb, self.codePage,
1271                                                DemoError(sys.exc_info()), self)
1272
1273             assert self.demoPage is not None, "runTest must return a window!"
1274
1275         else:
1276             # There was a previous error in compiling or exec-ing
1277             self.demoPage = DemoErrorPanel(self.nb, self.codePage,
1278                                            self.demoModules.GetErrorInfo(), self)
1279
1280         self.SetOverview(self.demoModules.name + " Overview", overviewText)
1281
1282         if self.firstTime:
1283             # cahnge to the demo page the first time a module is run
1284             self.UpdateNotebook(2)
1285             self.firstTime = False
1286         else:
1287             # otherwise just stay on the same tab in case the user has changed to another one
1288             self.UpdateNotebook()
1289
1290     #---------------------------------------------
1291     def ShutdownDemoModule(self):
1292         if self.demoPage:
1293             # inform the window that it's time to quit if it cares
1294             if hasattr(self.demoPage, "ShutdownDemo"):
1295                 self.demoPage.ShutdownDemo()
1296             wx.YieldIfNeeded() # in case the page has pending events
1297             self.demoPage = None
1298
1299     #---------------------------------------------
1300     def UpdateNotebook(self, select = -1):
1301         nb = self.nb
1302         debug = False
1303
1304         def UpdatePage(page, pageText):
1305             pageExists = False
1306             pagePos = -1
1307             for i in range(nb.GetPageCount()):
1308                 if nb.GetPageText(i) == pageText:
1309                     pageExists = True
1310                     pagePos = i
1311                     break
1312
1313             if page:
1314                 if not pageExists:
1315                     # Add a new page
1316                     nb.AddPage(page, pageText)
1317                     if debug: wx.LogMessage("DBG: ADDED %s" % pageText)
1318                 else:
1319                     if nb.GetPage(pagePos) != page:
1320                         # Reload an existing page
1321                         nb.Freeze()
1322                         nb.DeletePage(pagePos)
1323                         nb.InsertPage(pagePos, page, pageText)
1324                         nb.Thaw()
1325                         if debug: wx.LogMessage("DBG: RELOADED %s" % pageText)
1326                     else:
1327                         # Excellent! No redraw/flicker
1328                         if debug: wx.LogMessage("DBG: SAVED from reloading %s" % pageText)
1329             elif pageExists:
1330                 # Delete a page
1331                 nb.DeletePage(pagePos)
1332                 if debug: wx.LogMessage("DBG: DELETED %s" % pageText)
1333             else:
1334                 if debug: wx.LogMessage("DBG: STILL GONE - %s" % pageText)
1335
1336         if select == -1:
1337             select = nb.GetSelection()
1338
1339         UpdatePage(self.codePage, "Demo Code")
1340         UpdatePage(self.demoPage, "Demo")
1341
1342         if select >= 0 and select < nb.GetPageCount():
1343             nb.SetSelection(select)
1344
1345     #---------------------------------------------
1346     def SetOverview(self, name, text):
1347         self.curOverview = text
1348         lead = text[:6]
1349         if lead != '<html>' and lead != '<HTML>':
1350             text = '<br>'.join(text.split('\n'))
1351         if wx.USE_UNICODE:
1352             text = text.decode('iso8859_1')
1353         self.ovr.SetPage(text)
1354         self.nb.SetPageText(0, name)
1355
1356     #---------------------------------------------
1357     # Menu methods
1358     def OnFileExit(self, *event):
1359         self.Close()
1360
1361     def OnToggleRedirect(self, event):
1362         app = wx.GetApp()
1363         if event.Checked():
1364             app.RedirectStdio()
1365             print "Print statements and other standard output will now be directed to this window."
1366         else:
1367             app.RestoreStdio()
1368             print "Print statements and other standard output will now be sent to the usual location."
1369
1370     def OnHelpAbout(self, event):
1371         from About import MyAboutBox
1372         about = MyAboutBox(self)
1373         about.ShowModal()
1374         about.Destroy()
1375
1376     def OnHelpFind(self, event):
1377         self.nb.SetSelection(1)
1378         self.finddlg = wx.FindReplaceDialog(self, self.finddata, "Find",
1379                         wx.FR_NOUPDOWN |
1380                         wx.FR_NOMATCHCASE |
1381                         wx.FR_NOWHOLEWORD)
1382         self.finddlg.Show(True)
1383
1384     def OnFind(self, event):
1385         editor = self.codePage.editor
1386         self.nb.SetSelection(1)
1387         end = editor.GetLastPosition()
1388         textstring = editor.GetRange(0, end).lower()
1389         start = editor.GetSelection()[1]
1390         findstring = self.finddata.GetFindString().lower()
1391         loc = textstring.find(findstring, start)
1392         if loc == -1 and start != 0:
1393             # string not found, start at beginning
1394             start = 0
1395             loc = textstring.find(findstring, start)
1396         if loc == -1:
1397             dlg = wx.MessageDialog(self, 'Find String Not Found',
1398                           'Find String Not Found in Demo File',
1399                           wx.OK | wx.ICON_INFORMATION)
1400             dlg.ShowModal()
1401             dlg.Destroy()
1402         if self.finddlg:
1403             if loc == -1:
1404                 self.finddlg.SetFocus()
1405                 return
1406             else:
1407                 self.finddlg.Destroy()
1408         editor.ShowPosition(loc)
1409         editor.SetSelection(loc, loc + len(findstring))
1410
1411
1412
1413     def OnFindNext(self, event):
1414         if self.finddata.GetFindString():
1415             self.OnFind(event)
1416         else:
1417             self.OnHelpFind(event)
1418
1419     def OnFindClose(self, event):
1420         event.GetDialog().Destroy()
1421
1422
1423     def OnOpenShellWindow(self, evt):
1424         if self.shell:
1425             # if it already exists then just make sure it's visible
1426             s = self.shell
1427             if s.IsIconized():
1428                 s.Iconize(False)
1429             s.Raise()
1430         else:
1431             # Make a PyShell window
1432             from wx import py
1433             namespace = { 'wx'    : wx,
1434                           'app'   : wx.GetApp(),
1435                           'frame' : self,
1436                           }
1437             self.shell = py.shell.ShellFrame(None, locals=namespace)
1438             self.shell.SetSize((640,480))
1439             self.shell.Show()
1440
1441             # Hook the close event of the main frame window so that we
1442             # close the shell at the same time if it still exists
1443             def CloseShell(evt):
1444                 if self.shell:
1445                     self.shell.Close()
1446                 evt.Skip()
1447             self.Bind(wx.EVT_CLOSE, CloseShell)
1448
1449
1450     #---------------------------------------------
1451     def OnCloseWindow(self, event):
1452         self.dying = True
1453         self.demoPage = None
1454         self.codePage = None
1455         self.mainmenu = None
1456         self.Destroy()
1457
1458
1459     #---------------------------------------------
1460     def OnIdle(self, event):
1461         if self.otherWin:
1462             self.otherWin.Raise()
1463             self.demoPage = self.otherWin
1464             self.otherWin = None
1465
1466
1467     #---------------------------------------------
1468     def ShowTip(self):
1469         try:
1470             showTipText = open(opj("data/showTips")).read()
1471             showTip, index = eval(showTipText)
1472         except IOError:
1473             showTip, index = (1, 0)
1474         if showTip:
1475             tp = wx.CreateFileTipProvider(opj("data/tips.txt"), index)
1476             ##tp = MyTP(0)
1477             showTip = wx.ShowTip(self, tp)
1478             index = tp.GetCurrentTip()
1479             open(opj("data/showTips"), "w").write(str( (showTip, index) ))
1480
1481
1482     #---------------------------------------------
1483     def OnDemoMenu(self, event):
1484         try:
1485             selectedDemo = self.treeMap[self.mainmenu.GetLabel(event.GetId())]
1486         except:
1487             selectedDemo = None
1488         if selectedDemo:
1489             self.tree.SelectItem(selectedDemo)
1490             self.tree.EnsureVisible(selectedDemo)
1491
1492
1493     #---------------------------------------------
1494     def OnTaskBarActivate(self, evt):
1495         if self.IsIconized():
1496             self.Iconize(False)
1497         if not self.IsShown():
1498             self.Show(True)
1499         self.Raise()
1500
1501     #---------------------------------------------
1502
1503     TBMENU_RESTORE = 1000
1504     TBMENU_CLOSE   = 1001
1505
1506     def OnTaskBarMenu(self, evt):
1507         menu = wx.Menu()
1508         menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
1509         menu.Append(self.TBMENU_CLOSE,   "Close")
1510         self.tbicon.PopupMenu(menu)
1511         menu.Destroy()
1512
1513     #---------------------------------------------
1514     def OnTaskBarClose(self, evt):
1515         self.Close()
1516
1517         # because of the way wx.TaskBarIcon.PopupMenu is implemented we have to
1518         # prod the main idle handler a bit to get the window to actually close
1519         wx.GetApp().ProcessIdle()
1520
1521
1522     #---------------------------------------------
1523     def OnIconfiy(self, evt):
1524         wx.LogMessage("OnIconfiy: %d" % evt.Iconized())
1525         evt.Skip()
1526
1527     #---------------------------------------------
1528     def OnMaximize(self, evt):
1529         wx.LogMessage("OnMaximize")
1530         evt.Skip()
1531
1532
1533
1534
1535 #---------------------------------------------------------------------------
1536 #---------------------------------------------------------------------------
1537
1538 class MySplashScreen(wx.SplashScreen):
1539     def __init__(self):
1540         bmp = wx.Image(opj("bitmaps/splash.gif")).ConvertToBitmap()
1541         wx.SplashScreen.__init__(self, bmp,
1542                                  wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT,
1543                                  3000, None, -1)
1544         self.Bind(wx.EVT_CLOSE, self.OnClose)
1545
1546     def OnClose(self, evt):
1547         self.Hide()
1548         frame = wxPythonDemo(None, "wxPython: (A Demonstration)")
1549         frame.Show()
1550         evt.Skip()  # Make sure the default handler runs too...
1551
1552
1553 class MyApp(wx.App):
1554     def OnInit(self):
1555         """
1556         Create and show the splash screen.  It will then create and show
1557         the main frame when it is time to do so.
1558         """
1559
1560         # For debugging
1561         #self.SetAssertMode(wx.PYAPP_ASSERT_DIALOG)
1562
1563         # Normally when using a SplashScreen you would create it, show
1564         # it and then continue on with the applicaiton's
1565         # initialization, finally creating and showing the main
1566         # application window(s).  In this case we have nothing else to
1567         # do so we'll delay showing the main frame until later (see
1568         # OnClose above) so the users can see the SplashScreen effect.
1569         splash = MySplashScreen()
1570         splash.Show()
1571
1572         return True
1573
1574
1575
1576 #---------------------------------------------------------------------------
1577
1578 def main():
1579     try:
1580         demoPath = os.path.dirname(__file__)
1581         os.chdir(demoPath)
1582     except:
1583         pass
1584     app = MyApp(False)
1585     app.MainLoop()
1586
1587 #---------------------------------------------------------------------------
1588
1589
1590 mainOverview = """<html><body>
1591 <h2>wxPython</h2>
1592
1593 <p> wxPython is a <b>GUI toolkit</b> for the Python programming
1594 language.  It allows Python programmers to create programs with a
1595 robust, highly functional graphical user interface, simply and easily.
1596 It is implemented as a Python extension module (native code) that
1597 wraps the popular wxWindows cross platform GUI library, which is
1598 written in C++.
1599
1600 <p> Like Python and wxWindows, wxPython is <b>Open Source</b> which
1601 means that it is free for anyone to use and the source code is
1602 available for anyone to look at and modify.  Or anyone can contribute
1603 fixes or enhancements to the project.
1604
1605 <p> wxPython is a <b>cross-platform</b> toolkit.  This means that the
1606 same program will run on multiple platforms without modification.
1607 Currently supported platforms are 32-bit Microsoft Windows, most Unix
1608 or unix-like systems, and Macintosh OS X. Since the language is
1609 Python, wxPython programs are <b>simple, easy</b> to write and easy to
1610 understand.
1611
1612 <p> <b>This demo</b> is not only a collection of test cases for
1613 wxPython, but is also designed to help you learn about and how to use
1614 wxPython.  Each sample is listed in the tree control on the left.
1615 When a sample is selected in the tree then a module is loaded and run
1616 (usually in a tab of this notebook,) and the source code of the module
1617 is loaded in another tab for you to browse and learn from.
1618
1619 """
1620
1621
1622 #----------------------------------------------------------------------------
1623 #----------------------------------------------------------------------------
1624
1625 if __name__ == '__main__':
1626     __name__ = 'Main'
1627     main()
1628
1629 #----------------------------------------------------------------------------
1630
1631
1632
1633
1634
1635
1636