wxPython/wx/lib/infoframe.py

   1 # 12/20/2003 - Jeff Grimmett (grimmtooth@softhome.net)
   2 #
   3 # o wxPyInformationalMessagesFrame -> PyInformationalMessagesFrame
   4 # o dummy_wxPyInformationalMessagesFrame -> dummy_PyInformationalMessagesFrame
   5 #
   6
   7 """
   8 infoframe.py
   9 Released under wxWindows license etc.
  10
  11 This is a fairly rudimentary, but slightly fancier tha
  12 wxPyOnDemandOutputWindow (on which it's based; thanks Robin), version
  13 of the same sort of thing: a file-like class called
  14 wxInformationalMessagesFrame. This window also has a status bar with a
  15 couple of buttons for controlling the echoing of all output to a file
  16 with a randomly-chosen filename...
  17
  18 The class behaves similarly to wxPyOnDemandOutputWindow in that (at
  19 least by default) the frame does not appear until written to, but is
  20 somewhat different in that, either under programmatic (the
  21 DisableOutput method) or user (the frame's close button, it's status
  22 bar's "Dismiss" button, or a "Disable output" item of some menu,
  23 perhaps of some other frame), the frame will be destroyed, an
  24 associated file closed, and writing to it will then do nothing.  This
  25 can be reversed: either under programmatic (the EnableOutput method)
  26 or user (an "Enable output" item of some menu), a new frame will be
  27 opened,And an associated file (with a "randomly"selected filename)
  28 opened for writing [to which all subsequent displayed messages will be
  29 echoed].
  30
  31 Please note that, like wxPyOnDemandOutputWindow, the instance is not
  32 itself a subclass of wxWindow: when the window is open (and ONLY
  33 then), it's "frame" attribute is the actual instance of wFrame...
  34
  35 Typical usage::
  36
  37     from wxPython.lib.infoframe import *
  38     ... # ... modify your wxApp as follows:
  39     class myApp(wxApp):
  40         outputWindowClass = PyInformationalMessagesFrame
  41         ...
  42
  43 If you're running on Linux, you'll also have to supply an argument 1 to your
  44 constructor of myApp to redirect stdout/stderr to this window (it's done
  45 automatically for you on Windows).
  46
  47 If you don't want to redirect stdout/stderr, but use the class directly: do
  48 it this way::
  49
  50  InformationalMessagesFrame = PyInformationalMessagesFrame\
  51                                          ([options from progname (default ""),
  52                                            txt (default "informational messages"])
  53
  54 #^^^^ early in the program
  55 ...
  56 InformationalMessagesFrame([comma-separated list of items to
  57                              display.  Note that these will never
  58                              be separated by spaces as they may
  59                              be when used in the Python 'print'
  60                              command])
  61
  62 The latter statement, of course, may be repeated arbitrarily often.
  63 The window will not appear until it is written to, and it may be
  64 manually closed by the user, after which it will reappear again until
  65 written to... Also note that all output is echoed to a file with a
  66 randomly-generated name [see the mktemp module in the standard
  67 library], in the directory given as the 'dir' keyword argument to the
  68 InformationalMessagesFrame constructor [which has a default value of
  69 '.'), or set via the method SetOutputDirectory... This file will be
  70 closed with the window--a new one will be created [by default] upon
  71 each subsequent reopening.
  72
  73 Please also note the methods EnableOutput and DisableOutput, and the
  74 possible arguments for the constructor in the code below... (* TO DO:
  75 explain this here...*) Neither of these methods need be used at all,
  76 and in this case the frame will only be displayed once it has been
  77 written to, like wxPyOnDemandOutputWindow.
  78
  79 The former, EnableOutput, displays the frame with an introductory
  80 message, opens a random file to which future displayed output also
  81 goes (unless the nofile attribute is present), and sets the __debug__
  82 variable of each module to 1 (unless the no __debug__ attribute is
  83 present].  This is so that you can say, in any module whatsoever,
  84
  85     if __debug__:
  86         InformationalMessagesFrame("... with lots of %<Character> constructs"
  87                                     % TUPLE)
  88
  89 without worrying about the overhead of evaluating the arguments, and
  90 calling the wxInformationalMessagesFrame instance, in the case where
  91 debugging is not turned on.  (This won't happen if the instance has an
  92 attribute no__debug__; you can arrange this by sub-classing...)
  93
  94 "Debug mode" can also be turned on by selecting the item-"Enable
  95 output" from the "Debug" menu [the default--see the optional arguments
  96 to the SetOtherMenuBar method] of a frame which has been either passed
  97 appropriately to the constructor of the wxInformationalMessagesFrame
  98 (see the code), or set via the SetOtherMenuBar method thereof.  This
  99 also writes an empty string to the instance, meaning that the frame
 100 will open (unless DisablOutput has been called) with an appropriate
 101 introductory message (which will vary according to whether the
 102 instance/class has the "no __debug__" attribute)^  I have found this to
 103 be an extremely useful tool, in lieu of a full wxPython debugger...
 104
 105 Following this, the menu item is also disabled, and an item "Disable
 106 output" (again, by default) is enabled.  Note that these need not be
 107 done: e.g., you don't NEED to have a menu with appropriate items; in
 108 this case simply do not call the SetOtherMenuBar method or use the
 109 othermenubar keyword argument of the class instance constructor.
 110
 111 The DisableOutput method does the reverse of this; it closes the
 112 window (and associated file), and sets the __debug__ variable of each
 113 module whose name begins with a capital letter {this happens to be the
 114 author's personal practice; all my python module start with capital
 115 letters} to 0.  It also enables/disabled the appropriate menu items,
 116 if this was done previously (or SetOtherMenuBar has been called...).
 117 Note too that after a call to DisableOutput, nothing further will be
 118 done upon subsequent write()'s, until the EnableOutput method is
 119 called, either explicitly or by the menu selection above...
 120
 121 Finally, note that the file-like method close() destroys the window
 122 (and closes any associated file) and there is a file-like method
 123 write() which displays it's argument.
 124
 125 All (well, most) of this is made clear by the example code at the end
 126 of this file, which is run if the file is run by itself; otherwise,
 127 see the appropriate "stub" file in the wxPython demo.
 128
 129 """
 130
 131 import  os
 132 import  sys
 133 import  tempfile
 134
 135 import  wx
 136
 137 class _MyStatusBar(wx.StatusBar):
 138     def __init__(self, parent, callbacks=None, useopenbutton=0):
 139         wx.StatusBar.__init__(self, parent, -1, style=wx.TAB_TRAVERSAL)
 140         self.SetFieldsCount(3)
 141
 142         self.SetStatusText("",0)
 143
 144         self.button1 = wx.Button(self, -1, "Dismiss", style=wx.TAB_TRAVERSAL)
 145         self.Bind(wx.EVT_BUTTON, self.OnButton1, self.button1)
 146
 147         if not useopenbutton:
 148             self.button2 = wx.Button(self, -1, "Close File", style=wx.TAB_TRAVERSAL)
 149         else:
 150             self.button2 = wx.Button(self, -1, "Open New File", style=wx.TAB_TRAVERSAL)
 151
 152         self.Bind(wx.EVT_BUTTON, self.OnButton2, self.button2)
 153         self.useopenbutton = useopenbutton
 154         self.callbacks = callbacks
 155
 156         # figure out how tall to make the status bar
 157         dc = wx.ClientDC(self)
 158         dc.SetFont(self.GetFont())
 159         (w,h) = dc.GetTextExtent('X')
 160         h = int(h * 1.8)
 161         self.SetSize((100, h))
 162         self.OnSize("dummy")
 163         self.Bind(wx.EVT_SIZE, self.OnSize)
 164
 165     # reposition things...
 166     def OnSize(self, event):
 167         self.CalculateSizes()
 168         rect = self.GetFieldRect(1)
 169         self.button1.SetPosition((rect.x+5, rect.y+2))
 170         self.button1.SetSize((rect.width-10, rect.height-4))
 171         rect = self.GetFieldRect(2)
 172         self.button2.SetPosition((rect.x+5, rect.y+2))
 173         self.button2.SetSize((rect.width-10, rect.height-4))
 174
 175     # widths........
 176     def CalculateSizes(self):
 177         dc = wx.ClientDC(self.button1)
 178         dc.SetFont(self.button1.GetFont())
 179         (w1,h) = dc.GetTextExtent(self.button1.GetLabel())
 180
 181         dc = wx.ClientDC(self.button2)
 182         dc.SetFont(self.button2.GetFont())
 183         (w2,h) = dc.GetTextExtent(self.button2.GetLabel())
 184
 185         self.SetStatusWidths([-1,w1+15,w2+15])
 186
 187     def OnButton1(self,event):
 188         self.callbacks[0] ()
 189
 190     def OnButton2(self,event):
 191         if self.useopenbutton and self.callbacks[2] ():
 192                 self.button2.SetLabel ("Close File")
 193         elif self.callbacks[1] ():
 194                 self.button2.SetLabel ("Open New File")
 195
 196         self.useopenbutton = 1 - self.useopenbutton
 197         self.OnSize("")
 198         self.button2.Refresh(True)
 199         self.Refresh()
 200
 201
 202
 203 class PyInformationalMessagesFrame:
 204     def __init__(self,
 205                  progname="",
 206                  text="informational messages",
 207                  dir='.',
 208                  menuname="Debug",
 209                  enableitem="Enable output",
 210                  disableitem="Disable output",
 211                  othermenubar=None):
 212
 213         self.SetOtherMenuBar(othermenubar,
 214                              menuname=menuname,
 215                              enableitem=enableitem,
 216                              disableitem=disableitem)
 217
 218         if hasattr(self,"othermenu") and self.othermenu is not None:
 219             i = self.othermenu.FindMenuItem(self.menuname,self.disableitem)
 220             self.othermenu.Enable(i,0)
 221             i = self.othermenu.FindMenuItem(self.menuname,self.enableitem)
 222             self.othermenu.Enable(i,1)
 223
 224         self.frame  = None
 225         self.title  = "%s %s" % (progname,text)
 226         self.parent = None # use the SetParent method if desired...
 227         self.softspace = 1 # of rather limited use
 228
 229         if dir:
 230             self.SetOutputDirectory(dir)
 231
 232
 233     def SetParent(self, parent):
 234         self.parent = parent
 235
 236
 237     def SetOtherMenuBar(self,
 238                         othermenu,
 239                         menuname="Debug",
 240                         enableitem="Enable output",
 241                         disableitem="Disable output"):
 242         self.othermenu = othermenu
 243         self.menuname = menuname
 244         self.enableitem = enableitem
 245         self.disableitem = disableitem
 246
 247
 248     f = None
 249
 250
 251     def write(self, string):
 252         if not wx.Thread_IsMain():
 253             # Aquire the GUI mutex before making GUI calls.  Mutex is released
 254             # when locker is deleted at the end of this function.
 255             #
 256             # TODO: This should be updated to use wx.CallAfter similarly to how
 257             # PyOnDemandOutputWindow.write was so it is not necessary
 258             # to get the gui mutex
 259             locker = wx.MutexGuiLocker()
 260
 261         if self.Enabled:
 262             if self.f:
 263                 self.f.write(string)
 264                 self.f.flush()
 265
 266             move = 1
 267             if (hasattr(self,"text")
 268                 and self.text is not None
 269                 and self.text.GetInsertionPoint() != self.text.GetLastPosition()):
 270                 move = 0
 271
 272             if not self.frame:
 273                 self.frame = wx.Frame(self.parent, -1, self.title, size=(450, 300),
 274                                      style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)
 275
 276                 self.text  = wx.TextCtrl(self.frame, -1, "",
 277                                         style = wx.TE_MULTILINE|wx.TE_READONLY|wx.TE_RICH)
 278
 279                 self.frame.sb = _MyStatusBar(self.frame,
 280                                              callbacks=[self.DisableOutput,
 281                                                        self.CloseFile,
 282                                                        self.OpenNewFile],
 283                                              useopenbutton=hasattr(self,
 284                                                                   "nofile"))
 285                 self.frame.SetStatusBar(self.frame.sb)
 286                 self.frame.Show(True)
 287                 self.frame.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 288
 289                 if hasattr(self,"nofile"):
 290                     self.text.AppendText(
 291                         "Please close this window (or select the "
 292                         "'Dismiss' button below) when desired.  By "
 293                         "default all messages written to this window "
 294                         "will NOT be written to a file--you "
 295                         "may change this by selecting 'Open New File' "
 296                         "below, allowing you to select a "
 297                         "new file...\n\n")
 298                 else:
 299                     tempfile.tempdir = self.dir
 300                     filename = os.path.abspath(tempfile.mktemp ())
 301
 302                     self.text.AppendText(
 303                         "Please close this window (or select the "
 304                         "'Dismiss' button below) when desired.  By "
 305                         "default all messages written to this window "
 306                         "will also be written to the file '%s'--you "
 307                         "may close this file by selecting 'Close "
 308                         "File' below, whereupon this button will be "
 309                         "replaced with one allowing you to select a "
 310                         "new file...\n\n" % filename)
 311                     try:
 312                         self.f = open(filename, 'w')
 313                         self.frame.sb.SetStatusText("File '%s' opened..."
 314                                                     % filename,
 315                                                     0)
 316                     except EnvironmentError:
 317                         self.frame.sb.SetStatusText("File creation failed "
 318                                                     "(filename '%s')..."
 319                                                     % filename,
 320                                                     0)
 321             self.text.AppendText(string)
 322
 323             if move:
 324                 self.text.ShowPosition(self.text.GetLastPosition())
 325
 326             if  not hasattr(self,"no__debug__"):
 327                 for m in sys.modules.values():
 328                     if m is  not None:# and m.__dict__.has_key("__debug__"):
 329                         m.__dict__["__debug__"] = 1
 330
 331             if hasattr(self,"othermenu") and self.othermenu is not None:
 332                 i = self.othermenu.FindMenuItem(self.menuname,self.disableitem)
 333                 self.othermenu.Enable(i,1)
 334                 i = self.othermenu.FindMenuItem(self.menuname,self.enableitem)
 335                 self.othermenu.Enable(i,0)
 336
 337
 338     Enabled = 1
 339
 340     def OnCloseWindow(self, event, exiting=0):
 341         if self.f:
 342             self.f.close()
 343             self.f = None
 344
 345         if (hasattr(self,"othermenu") and self.othermenu is not None
 346             and self.frame is not None
 347             and not exiting):
 348
 349             i = self.othermenu.FindMenuItem(self.menuname,self.disableitem)
 350             self.othermenu.Enable(i,0)
 351             i = self.othermenu.FindMenuItem(self.menuname,self.enableitem)
 352             self.othermenu.Enable(i,1)
 353
 354         if  not hasattr(self,"no__debug__"):
 355             for m in sys.modules.values():
 356                 if m is  not None:# and m.__dict__.has_key("__debug__"):
 357                     m.__dict__["__debug__"] = 0
 358
 359         if self.frame is not None: # typically True, but, e.g., allows
 360                                    # DisableOutput method (which calls this
 361                                    # one) to be called when the frame is not
 362                                    # actually open, so that it is always safe
 363                                    # to call this method...
 364             frame = self.frame
 365             self.frame = self.text = None
 366             frame.Destroy()
 367         self.Enabled = 1
 368
 369
 370     def EnableOutput(self,
 371                      event=None,# event must be the first optional argument...
 372                      othermenubar=None,
 373                      menuname="Debug",
 374                      enableitem="Enable output",
 375                      disableitem="Disable output"):
 376
 377         if othermenubar is not None:
 378             self.SetOtherMenuBar(othermenubar,
 379                                  menuname=menuname,
 380                                  enableitem=enableitem,
 381                                  disableitem=disableitem)
 382         self.Enabled = 1
 383         if self.f:
 384             self.f.close()
 385             self.f = None
 386         self.write("")
 387
 388
 389     def CloseFile(self):
 390         if self.f:
 391             if self.frame:
 392                 self.frame.sb.SetStatusText("File '%s' closed..."
 393                                             % os.path.abspath(self.f.name),
 394                                             0)
 395             self.f.close ()
 396             self.f = None
 397         else:
 398             if self.frame:
 399                 self.frame.sb.SetStatusText("")
 400         if self.frame:
 401             self.frame.sb.Refresh()
 402         return 1
 403
 404
 405     def OpenNewFile(self):
 406         self.CloseFile()
 407         dlg = wx.FileDialog(self.frame,
 408                           "Choose a new log file", self.dir,"","*",
 409                            wx.SAVE | wx.OVERWRITE_PROMPT)
 410         if dlg.ShowModal() == wx.ID_CANCEL:
 411             dlg.Destroy()
 412             return 0
 413         else:
 414             try:
 415                 self.f = open(os.path.abspath(dlg.GetPath()),'w')
 416             except EnvironmentError:
 417                 dlg.Destroy()
 418                 return 0
 419             dlg.Destroy()
 420             if self.frame:
 421                 self.frame.sb.SetStatusText("File '%s' opened..."
 422                                             % os.path.abspath(self.f.name),
 423                                             0)
 424                 if hasattr(self,"nofile"):
 425                     self.frame.sb = _MyStatusBar(self.frame,
 426                                                 callbacks=[self.DisableOutput,
 427                                                            self.CloseFile,
 428                                                            self.OpenNewFile])
 429                     self.frame.SetStatusBar(self.frame.sb)
 430             if hasattr(self,"nofile"):
 431                 delattr(self,"nofile")
 432             return 1
 433
 434
 435     def DisableOutput(self,
 436                       event=None,# event must be the first optional argument...
 437                       exiting=0):
 438         self.write("<InformationalMessagesFrame>.DisableOutput()\n")
 439         if hasattr(self,"frame") \
 440            and self.frame is not None:
 441             self.OnCloseWindow("Dummy",exiting=exiting)
 442         self.Enabled = 0
 443
 444
 445     def close(self):
 446         self.DisableOutput()
 447
 448
 449     def flush(self):
 450         if self.text:
 451             self.text.SetInsertionPointEnd()
 452         wx.Yield()
 453
 454
 455     def __call__(self,* args):
 456         for s in args:
 457             self.write (str (s))
 458
 459
 460     def SetOutputDirectory(self,dir):
 461         self.dir = os.path.abspath(dir)
 462 ##        sys.__stderr__.write("Directory: os.path.abspath(%s) = %s\n"
 463 ##                             % (dir,self.dir))
 464
 465
 466
 467 class Dummy_PyInformationalMessagesFrame:
 468     def __init__(self,progname=""):
 469         self.softspace = 1
 470     def __call__(self,*args):
 471         pass
 472     def write(self,s):
 473         pass
 474     def flush(self):
 475         pass
 476     def close(self):
 477         pass
 478     def EnableOutput(self):
 479         pass
 480     def __call__(self,* args):
 481         pass
 482     def DisableOutput(self,exiting=0):
 483         pass
 484     def SetParent(self,wX):
 485         pass
 486