wxPython/wxPython/lib/infoframe.py

   1 """
   2 infoframe.py
   3 Released under wxWindows license etc.
   4
   5 This is a fairly rudimentary, but slightly fancier tha
   6 wxPyOnDemandOutputWindow (on which it's based; thanks Robin), version
   7 of the same sort of thing: a file-like class called
   8 InformationalMessagesFrame.. This window also has a status bar with a
   9 couple of buttons for controlling the echoing of all output to a file
  10 with a randomly-chosen filename... [[A LITTLE MORE COULD BE SAID
  11 HERE]]
  12
  13 Typical usage:
  14     from wxPython.lib.infoframe import *
  15     ... # ... modify your wxApp as follows:
  16     class myApp[wxApp):
  17         outputWindowClass = wxInformationalMessagesFrame
  18         ...
  19 If you're running on Linux, you'll also have to supply an argument 1 to your
  20 constructor of myApp to redirect stdout/stderr to this window (it's done
  21 automatically for you on Windows).
  22
  23 If you don't want to redirect stdout/stderr, but use the class directly: do
  24 it this way:
  25
  26 InformationalMessagesFrame = wxInformationalMessagesFrame\
  27                                          ([options from progname (default ""),
  28                                            txt (default "informational
  29                                                          messages"])
  30 #^^^^ early in the program
  31 ...
  32 InformationalMessagesFrame([comma-separated list of items to
  33                              display.  Note that these will never
  34                              be separated by spaces as they may
  35                              be when used in the Python 'print'
  36                              command])
  37
  38 The latter statement, of course, may be repeated arbitrarily often.
  39 The window will not appear until it is written to, and it may be
  40 manually closed by the user, after which it will not appear again
  41 until written to... Also note that all output is echoed to a file with
  42 a randomly-generated name [see the mktemp module in the standard
  43 library], in the directory given as the 'dir' keyword argument to the
  44 InformationalMessagesFrame constructor [which has a default value of
  45 '.'), or set via the method SetOutputDirectory...
  46
  47 Please also note the methods EnableOutput and DisableOutput, and the
  48 possible arguments for the constructor in the code below... (* TO DO:
  49 explain this here...*) The former, EnableOutput, displays the frame
  50 with an introductory message, opens a random file to which future
  51 displayed output also goes, and sets the __debug__ variable of each
  52 module whose name begins with a capital letter {this happens to be the
  53 author's personal practice; all my python module start with capital
  54 letters} to 1.  This is so that you can say
  55
  56     if __debug__:
  57         InformationalMessagesFrame("... with lots of %<Character> constructs"
  58                                     % TUPLE)
  59
  60 without worrying about a huge about of overhead in the case where
  61 debugging is not turned on.  "Debug mode" can also be turned on by
  62 selecting the item-"Enable debugging output" from the "Debug" menu of
  63 a frame which has been either passed appropriately to the constructor
  64 of the wxInformationalMessagesFrame (see the code), or set via the
  65 SetOtherMenuBar method thereof.  (I have found this to be an extremely
  66 useful tool, in lieu of a full wxPython debugger...)  This menu item
  67 is also disabled, and an item "Disable debugging output" (which calls
  68 the method described in the next paragraph) is enabled.  Note that
  69 these things need not be done: e.g., you don't need to have a "Debug"
  70 menu with appropriate items; in this case simply do not call the
  71 SetOtherMenuBar method or use the othermenubar keyword argument of the
  72 class Instance constructor.
  73
  74 The DisableOutput method does the reverse of this; it closes the
  75 window (and associated file), and sets the __debug__ variable of each
  76 module whose name begins with a capital letter {this happens to be the
  77 author's personal practice; all my python module start with capital
  78 letters} to 0.  It also enables/disabled the appropriate menu items,
  79 if this was done previously (or SetOtherMenuBar has been called...).
  80
  81 Finally, note that the file-like method close() destroys the window
  82 (and any associated file) and there is a file-like method write()
  83 which displays it's argument [actually, it's very similar to
  84 DisableOutput).  Also, class instances are callable as noted above,
  85 displaying successive arguments if this is done.
  86
  87 """
  88
  89 from wxPython.wx import *
  90 import string, sys, types, tempfile, os
  91
  92 class _MyStatusBar(wxStatusBar):
  93     def __init__(self, parent,callbacks=None):
  94         wxStatusBar.__init__(self, parent, -1, style=wxTAB_TRAVERSAL)
  95         self.SetFieldsCount(3)
  96
  97         self.SetStatusText("",0)
  98
  99         ID = NewId()
 100         self.button1 = wxButton(self,ID,"Dismiss",
 101                                style=wxTAB_TRAVERSAL)
 102         EVT_BUTTON(self,ID,callbacks[0])
 103
 104         ID = NewId()
 105         self.button2 = wxButton(self,ID,"Close File",
 106                                style=wxTAB_TRAVERSAL)
 107         EVT_BUTTON(self,ID,self.OnButton2)
 108         self.usealternate = 0
 109         self.callbacks = [callbacks[1],callbacks[2]]
 110
 111         # figure out how tall to make the status bar
 112         dc = wxClientDC(self)
 113         dc.SetFont(self.GetFont())
 114         (w,h) = dc.GetTextExtent('X')
 115         h = int(h * 1.8)
 116         self.SetSize(wxSize(100, h))
 117         self.OnSize("dummy")
 118         EVT_SIZE(self,self.OnSize)
 119
 120     # reposition things...
 121     def OnSize(self, event):
 122         self.CalculateSizes()
 123         rect = self.GetFieldRect(1)
 124         self.button1.SetPosition(wxPoint(rect.x+5, rect.y+2))
 125         self.button1.SetSize(wxSize(rect.width-10, rect.height-4))
 126         rect = self.GetFieldRect(2)
 127         self.button2.SetPosition(wxPoint(rect.x+5, rect.y+2))
 128         self.button2.SetSize(wxSize(rect.width-10, rect.height-4))
 129
 130     # widths........
 131     def CalculateSizes(self):
 132         dc = wxClientDC(self.button1)
 133         dc.SetFont(self.button1.GetFont())
 134         (w1,h) = dc.GetTextExtent(self.button1.GetLabel())
 135
 136         dc = wxClientDC(self.button2)
 137         dc.SetFont(self.button2.GetFont())
 138         (w2,h) = dc.GetTextExtent(self.button2.GetLabel())
 139
 140         self.SetStatusWidths([-1,w1+15,w2+15])
 141
 142     def OnButton2(self,event):
 143         if self.usealternate:
 144             if self.callbacks[1] ():
 145                 self.button2.SetLabel ("Close File")
 146                 self.usealternate = 1 - self.usealternate
 147         else:
 148             if self.callbacks[0] ():
 149                 self.button2.SetLabel ("Open New File")
 150                 self.usealternate = 1 - self.usealternate
 151         self.OnSize("")
 152         self.button2.Refresh(TRUE)
 153         self.Refresh()
 154
 155 class wxInformationalMessagesFrame:#wxPyOnDemandOutputWindow):
 156     parent = None
 157
 158     def SetParent(self, parent):
 159         self.parent = parent
 160
 161     def SetOtherMenuBar(self,othermenu):
 162         self.othermenu = othermenu
 163
 164     def __init__(self,progname="",text="informational messages",dir=',',
 165                  othermenubar=None):
 166         self.othermenu = othermenubar
 167         self.frame  = None
 168         self.title  = "%s %s" % (progname,text)
 169         self.softspace = 1 # of rather limited use
 170         if dir:
 171             self.SetOutputDirectory(dir)
 172         if __debug__:
 173             self.EnableOutput()
 174         #wxPyOnDemandOutputWindow.__init__(self,self.title)
 175         for m in sys.modules.values():
 176             if m is  not None:# and m.__dict__.has_key("__debug__"):
 177                 m.__dict__["__debug__"] = self.Enabled
 178
 179     f = None
 180
 181     def write(self,string):
 182         if self.Enabled:
 183             if self.f:
 184                 self.f.write (string)
 185                 self.f.flush ()
 186             move = 1
 187             if hasattr(self,"text")\
 188                and self.text is not None\
 189                and self.text.GetInsertionPoint()\
 190                <> self.text.GetLastPosition():
 191                 move = 0
 192             if not self.frame:
 193                 self.frame = wxFrame(self.parent, -1, self.title)
 194                 self.text  = wxTextCtrl(self.frame, -1, "",
 195                                         style = wxTE_MULTILINE|wxTE_READONLY
 196                                         |wxTE_RICH)# appears to cause problem?
 197                 self.frame.sb = _MyStatusBar(self.frame,
 198                                             callbacks=[self.DisableOutput,
 199                                                        self.CloseFile,
 200                                                        self.OpenNewFile])
 201                 self.frame.SetStatusBar(self.frame.sb)
 202                 self.frame.SetSize(wxSize(450, 300))
 203                 self.frame.Show(true)
 204                 EVT_CLOSE(self.frame, self.OnCloseWindow)
 205             self.text.AppendText(string)
 206 ##            if __debug__ and type(sys.__stderr__) == types.FileType\
 207 ##               and sys.__stderr__.isatty():
 208 ##                sys.__stderr__.write(
 209 ##                    "%s.write(): self.text.GetInsertionPoint() = %s, "\
 210 ##                    "self.text.GetLastPosition() = %s, "\
 211 ##                    "move = %d\n" % (self,
 212 ##                                     self.text.GetInsertionPoint(),
 213 ##                                     self.text.GetLastPosition(),
 214 ##                                     move))
 215             if move:
 216                 self.text.ShowPosition(self.text.GetLastPosition())
 217
 218     Enabled = __debug__
 219
 220     def OnCloseWindow(self,event,exiting=0):
 221         if self.f:
 222             self.f.close()
 223             self.f = None
 224         if hasattr(self,"othermenu") and self.othermenu is not None\
 225            and self.frame is not None\
 226            and not exiting:
 227             i = self.othermenu.FindMenuItem('Debug','Disable debugging output')
 228             self.othermenu.Enable(i,0)
 229             i = self.othermenu.FindMenuItem('Debug','Enable debugging output')
 230             self.othermenu.Enable(i,1)
 231         for m in sys.modules.values():
 232             if m is  not None:# and m.__dict__.has_key("__debug__"):
 233                 m.__dict__["__debug__"] = 0
 234         if self.frame is not None: # should be true, but, e.g., allows
 235                                    # DisableOutput method (which calls this
 236                                    # one) to be called when the frame is not
 237                                    # actually open, so that it is always safe
 238                                    # to call this method...
 239             frame = self.frame
 240             self.frame = self.text = None
 241             frame.Destroy()
 242         self.Enabled = 0
 243
 244     def EnableOutput(self,othermenubar=None):
 245         if othermenubar is not None:
 246             self.othermenu = othermenubar
 247         self.Enabled = 1
 248         for m in sys.modules.values():
 249             if m is  not None:# and m.__dict__.has_key("__debug__"):
 250                 m.__dict__["__debug__"] = 1
 251         if hasattr(self,"othermenu") and self.othermenu is not None:
 252             i = self.othermenu.FindMenuItem('Debug','Disable debugging output')
 253             self.othermenu.Enable(i,1)
 254             i = self.othermenu.FindMenuItem('Debug','Enable debugging output')
 255             self.othermenu.Enable(i,0)
 256         if not self.f:
 257             try:
 258                 filename = tempfile.mktemp ()
 259                 self.write("Please close this window (or select the "
 260                            "'Dismiss' button below) when desired.  By "
 261                            "default all messages written to this window "
 262                            "will also be written to the file '%s'--you "
 263                            "may close this file by selecting 'Close "
 264                            "File' below, whereupon this button will be "
 265                            "replaced with one allowing you to select a "
 266                            "new file...\n\n" % os.path.abspath(filename))
 267                 self.f = open (filename,'w')
 268                 self.frame.sb.SetStatusText("File '%s' opened..."
 269                                             % os.path.abspath(self.f.name),
 270                                             0)
 271             except EnvironmentError:
 272                 self.frame.sb.SetStatusText("File creation failed (filename "
 273                                             "'%s')..."
 274                                             % os.path.abspath(filename),
 275                                             0)
 276
 277     def CloseFile(self):
 278         if self.f:
 279             if self.frame:
 280                 self.frame.sb.SetStatusText("File '%s' closed..."
 281                                             % os.path.abspath(self.f.name),
 282                                             0)
 283             self.f.close ()
 284             self.f = None
 285         else:
 286             if self.frame:
 287                 self.frame.sb.SetStatusText("")
 288         if self.frame:
 289             self.frame.sb.Refresh()
 290         return 1
 291
 292     def OpenNewFile(self):
 293         self.CloseFile()
 294         dlg = wxFileDialog(self.frame,
 295                           "Choose a new log file", self.dir,"","*",
 296                            wxSAVE | wxHIDE_READONLY | wxOVERWRITE_PROMPT)
 297         if dlg.ShowModal() == wxID_CANCEL:
 298             dlg.Destroy()
 299             return 0
 300         else:
 301             try:
 302                 self.f = open(os.path.abspath(dlg.GetPath()),'w')
 303             except EnvironmentError:
 304                 dlg.Destroy()
 305                 return 0
 306             dlg.Destroy()
 307             if self.frame:
 308                 self.frame.sb.SetStatusText("File '%s' opened..."
 309                                             % os.path.abspath(self.f.name),
 310                                             0)
 311             return 1
 312
 313     def DisableOutput(self,exiting=0):
 314         self.write("<InformationalMessagesFrame>.DisableOutput()\n")
 315         self.CloseFile()
 316         self.Enabled = 0
 317         if hasattr(self,"othermenu") and self.othermenu is not None:
 318             i = self.othermenu.FindMenuItem('Debug','Disable debugging output')
 319             self.othermenu.Enable(i,0)
 320             i = self.othermenu.FindMenuItem('Debug','Enable debugging output')
 321             self.othermenu.Enable(i,1)
 322         if hasattr(self,"frame") \
 323            and self.frame is not None:
 324             self.OnCloseWindow("Dummy",exiting=exiting)
 325
 326     def close(self):
 327         self.DisableOutput()
 328
 329     def flush(self):
 330         if self.text:
 331             self.text.SetInsertionPointEnd()
 332         wxYield()
 333
 334     def __call__(self,* args):
 335         for s in args:
 336             self.write (str (s))
 337
 338     def SetOutputDirectory(self,dir):
 339         self.dir = tempfile.tempdir = dir
 340
 341 class DummyFile:
 342     def __init__(self,progname=""):
 343         self.softspace = 1
 344     def __call__(self,*args):
 345         pass
 346     def write(self,s):
 347         pass
 348     def flush(self):
 349         pass
 350     def close(self):
 351         pass
 352     def EnableOutput(self):
 353         pass
 354     def __call__(self,* args):
 355         pass
 356     def DisableOutput(self,exiting=0):
 357         pass
 358     def SetParent(self,wX):
 359         pass
 360
 361 if __name__ == "__main__":
 362     __debug__ = 1
 363
 364     ImportErrors = 0
 365     try:
 366         import Errors
 367         importErrors = 1
 368     except ImportError:
 369         pass
 370
 371     class MyFrame(wxFrame):
 372         def __init__(self):
 373             wxFrame.__init__(self,None,-1,"Close me...",size=(300,10))
 374             EVT_CLOSE(self,self.OnClose)
 375
 376         def OnClose(self,event):
 377             if isinstance(sys.stdout,wxInformationalMessagesFrame):
 378                 sys.stdout.close()# shouldn't be necessary?
 379             self.Destroy()
 380
 381     class MyApp(wxApp):
 382         outputWindowClass = wxInformationalMessagesFrame
 383         def OnInit(self):
 384             if ImportErrors:
 385                 sys.stderr = Errors.NonWindowingErrorWindow(
 386                     file=self.stdioWin)
 387             print "Starting.\n",
 388             frame = MyFrame()
 389             frame.Show(TRUE)
 390             self.SetTopWindow(frame)
 391             if isinstance(sys.stdout,wxInformationalMessagesFrame):
 392                 sys.stdout.SetParent(frame)#  Shouldn't this mean the
 393                 #wxInternationalMessagesFrame is Destroy()'d when MFrame is?
 394             return true
 395
 396     app = MyApp()
 397     app.MainLoop()