wxPython/demo/Main.py

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