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