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