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