wxPython/src/_app_ex.py

   1
   2 #----------------------------------------------------------------------
   3
   4 class PyOnDemandOutputWindow:
   5     """
   6     A class that can be used for redirecting Python's stdout and
   7     stderr streams.  It will do nothing until something is wrriten to
   8     the stream at which point it will create a Frame with a text area
   9     and write the text there.
  10     """
  11     def __init__(self, title = "wxPython: stdout/stderr"):
  12         self.frame  = None
  13         self.title  = title
  14         self.pos    = wx.DefaultPosition
  15         self.size   = (450, 300)
  16         self.parent = None
  17
  18     def SetParent(self, parent):
  19         """Set the window to be used as the popup Frame's parent."""
  20         self.parent = parent
  21
  22
  23     def CreateOutputWindow(self, st):
  24         self.frame = wx.Frame(self.parent, -1, self.title, self.pos, self.size,
  25                               style=wx.DEFAULT_FRAME_STYLE)
  26         self.text  = wx.TextCtrl(self.frame, -1, "",
  27                                  style=wx.TE_MULTILINE|wx.TE_READONLY)
  28         self.text.AppendText(st)
  29         self.frame.Show(True)
  30         EVT_CLOSE(self.frame, self.OnCloseWindow)
  31
  32
  33     def OnCloseWindow(self, event):
  34         if self.frame is not None:
  35             self.frame.Destroy()
  36         self.frame = None
  37         self.text  = None
  38
  39
  40     # These methods provide the file-like output behaviour.
  41     def write(self, text):
  42         """
  43         Create the output window if needed and write the string to it.
  44         If not called in the context of the gui thread then uses
  45         CallAfter to do the work there.
  46         """
  47         if self.frame is None:
  48             if not wx.Thread_IsMain():
  49                 wx.CallAfter(self.CreateOutputWindow, text)
  50             else:
  51                 self.CreateOutputWindow(text)
  52         else:
  53             if not wx.Thread_IsMain():
  54                 wx.CallAfter(self.text.AppendText, text)
  55             else:
  56                 self.text.AppendText(text)
  57
  58
  59     def close(self):
  60         if self.frame is not None:
  61             wx.CallAfter(self.frame.Close)
  62
  63
  64     def flush(self):
  65         pass
  66
  67
  68
  69 #----------------------------------------------------------------------
  70
  71 _defRedirect = (wx.Platform == '__WXMSW__' or wx.Platform == '__WXMAC__')
  72
  73 class App(wx.PyApp):
  74     """
  75     The ``wx.App`` class represents the application and is used to:
  76
  77       * bootstrap the wxPython system and initialize the underlying
  78         gui toolkit
  79       * set and get application-wide properties
  80       * implement the windowing system main message or event loop,
  81         and to dispatch events to window instances
  82       * etc.
  83
  84     Every application must have a ``wx.App`` instance, and all
  85     creation of UI objects should be delayed until after the
  86     ``wx.App`` object has been created in order to ensure that the gui
  87     platform and wxWidgets have been fully initialized.
  88
  89     Normally you would derive from this class and implement an
  90     ``OnInit`` method that creates a frame and then calls
  91     ``self.SetTopWindow(frame)``.
  92
  93     :see: `wx.PySimpleApp` for a simpler app class that can be used
  94            directly.
  95     """
  96
  97     outputWindowClass = PyOnDemandOutputWindow
  98
  99     def __init__(self, redirect=_defRedirect, filename=None,
 100                  useBestVisual=False, clearSigInt=True):
 101         """
 102         Construct a ``wx.App`` object.
 103
 104         :param redirect: Should ``sys.stdout`` and ``sys.stderr`` be
 105             redirected?  Defaults to True on Windows and Mac, False
 106             otherwise.  If `filename` is None then output will be
 107             redirected to a window that pops up as needed.  (You can
 108             control what kind of window is created for the output by
 109             resetting the class variable ``outputWindowClass`` to a
 110             class of your choosing.)
 111
 112         :param filename: The name of a file to redirect output to, if
 113             redirect is True.
 114
 115         :param useBestVisual: Should the app try to use the best
 116             available visual provided by the system (only relevant on
 117             systems that have more than one visual.)  This parameter
 118             must be used instead of calling `SetUseBestVisual` later
 119             on because it must be set before the underlying GUI
 120             toolkit is initialized.
 121
 122         :param clearSigInt: Should SIGINT be cleared?  This allows the
 123             app to terminate upon a Ctrl-C in the console like other
 124             GUI apps will.
 125
 126         :note: You should override OnInit to do applicaition
 127             initialization to ensure that the system, toolkit and
 128             wxWidgets are fully initialized.
 129         """
 130         wx.PyApp.__init__(self)
 131
 132         if wx.Platform == "__WXMAC__":
 133             try:
 134                 import MacOS
 135                 if not MacOS.WMAvailable():
 136                     print """\
 137 This program needs access to the screen. Please run with 'pythonw',
 138 not 'python', and only when you are logged in on the main display of
 139 your Mac."""
 140                     _sys.exit(1)
 141             except SystemExit:
 142                 raise
 143             except:
 144                 pass
 145
 146         # This has to be done before OnInit
 147         self.SetUseBestVisual(useBestVisual)
 148
 149         # Set the default handler for SIGINT.  This fixes a problem
 150         # where if Ctrl-C is pressed in the console that started this
 151         # app then it will not appear to do anything, (not even send
 152         # KeyboardInterrupt???)  but will later segfault on exit.  By
 153         # setting the default handler then the app will exit, as
 154         # expected (depending on platform.)
 155         if clearSigInt:
 156             try:
 157                 import signal
 158                 signal.signal(signal.SIGINT, signal.SIG_DFL)
 159             except:
 160                 pass
 161
 162         # Save and redirect the stdio to a window?
 163         self.stdioWin = None
 164         self.saveStdio = (_sys.stdout, _sys.stderr)
 165         if redirect:
 166             self.RedirectStdio(filename)
 167
 168         # Use Python's install prefix as the default
 169         wx.StandardPaths.Get().SetInstallPrefix(_sys.prefix)
 170
 171         # This finishes the initialization of wxWindows and then calls
 172         # the OnInit that should be present in the derived class
 173         self._BootstrapApp()
 174
 175
 176     def __del__(self, destroy=wx.PyApp.__del__):
 177         self.RestoreStdio()  # Just in case the MainLoop was overridden
 178         destroy(self)
 179
 180     def Destroy(self):
 181         wx.PyApp.Destroy(self)
 182         self.thisown = 0
 183
 184     def SetTopWindow(self, frame):
 185         """Set the \"main\" top level window"""
 186         if self.stdioWin:
 187             self.stdioWin.SetParent(frame)
 188         wx.PyApp.SetTopWindow(self, frame)
 189
 190
 191     def MainLoop(self):
 192         """Execute the main GUI event loop"""
 193         wx.PyApp.MainLoop(self)
 194         self.RestoreStdio()
 195
 196
 197     def RedirectStdio(self, filename=None):
 198         """Redirect sys.stdout and sys.stderr to a file or a popup window."""
 199         if filename:
 200             _sys.stdout = _sys.stderr = open(filename, 'a')
 201         else:
 202             self.stdioWin = self.outputWindowClass()
 203             _sys.stdout = _sys.stderr = self.stdioWin
 204
 205
 206     def RestoreStdio(self):
 207         try:
 208             _sys.stdout, _sys.stderr = self.saveStdio
 209         except:
 210             pass
 211
 212
 213     def SetOutputWindowAttributes(self, title=None, pos=None, size=None):
 214         """
 215         Set the title, position and/or size of the output window if
 216         the stdio has been redirected.  This should be called before
 217         any output would cause the output window to be created.
 218         """
 219         if self.stdioWin:
 220             if title is not None:
 221                 self.stdioWin.title = title
 222             if pos is not None:
 223                 self.stdioWin.pos = pos
 224             if size is not None:
 225                 self.stdioWin.size = size
 226
 227
 228
 229
 230 # change from wx.PyApp_XX to wx.App_XX
 231 App_GetMacSupportPCMenuShortcuts = _core_.PyApp_GetMacSupportPCMenuShortcuts
 232 App_GetMacAboutMenuItemId        = _core_.PyApp_GetMacAboutMenuItemId
 233 App_GetMacPreferencesMenuItemId  = _core_.PyApp_GetMacPreferencesMenuItemId
 234 App_GetMacExitMenuItemId         = _core_.PyApp_GetMacExitMenuItemId
 235 App_GetMacHelpMenuTitleName      = _core_.PyApp_GetMacHelpMenuTitleName
 236 App_SetMacSupportPCMenuShortcuts = _core_.PyApp_SetMacSupportPCMenuShortcuts
 237 App_SetMacAboutMenuItemId        = _core_.PyApp_SetMacAboutMenuItemId
 238 App_SetMacPreferencesMenuItemId  = _core_.PyApp_SetMacPreferencesMenuItemId
 239 App_SetMacExitMenuItemId         = _core_.PyApp_SetMacExitMenuItemId
 240 App_SetMacHelpMenuTitleName      = _core_.PyApp_SetMacHelpMenuTitleName
 241 App_GetComCtl32Version           = _core_.PyApp_GetComCtl32Version
 242
 243 #----------------------------------------------------------------------------
 244
 245 class PySimpleApp(wx.App):
 246     """
 247     A simple application class.  You can just create one of these and
 248     then then make your top level windows later, and not have to worry
 249     about OnInit.  For example::
 250
 251         app = wx.PySimpleApp()
 252         frame = wx.Frame(None, title='Hello World')
 253         frame.Show()
 254         app.MainLoop()
 255
 256     :see: `wx.App`
 257     """
 258
 259     def __init__(self, redirect=False, filename=None,
 260                  useBestVisual=False, clearSigInt=True):
 261         """
 262         :see: `wx.App.__init__`
 263         """
 264         wx.App.__init__(self, redirect, filename, useBestVisual, clearSigInt)
 265
 266     def OnInit(self):
 267         return True
 268
 269
 270
 271 # Is anybody using this one?
 272 class PyWidgetTester(wx.App):
 273     def __init__(self, size = (250, 100)):
 274         self.size = size
 275         wx.App.__init__(self, 0)
 276
 277     def OnInit(self):
 278         self.frame = wx.Frame(None, -1, "Widget Tester", pos=(0,0), size=self.size)
 279         self.SetTopWindow(self.frame)
 280         return True
 281
 282     def SetWidget(self, widgetClass, *args, **kwargs):
 283         w = widgetClass(self.frame, *args, **kwargs)
 284         self.frame.Show(True)
 285
 286 #----------------------------------------------------------------------------
 287 # DO NOT hold any other references to this object.  This is how we
 288 # know when to cleanup system resources that wxWidgets is holding.  When
 289 # the sys module is unloaded, the refcount on sys.__wxPythonCleanup
 290 # goes to zero and it calls the wx.App_CleanUp function.
 291
 292 class __wxPyCleanup:
 293     def __init__(self):
 294         self.cleanup = _core_.App_CleanUp
 295     def __del__(self):
 296         self.cleanup()
 297
 298 _sys.__wxPythonCleanup = __wxPyCleanup()
 299
 300 ## # another possible solution, but it gets called too early...
 301 ## import atexit
 302 ## atexit.register(_core_.wxApp_CleanUp)
 303
 304
 305 #----------------------------------------------------------------------------