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