Lib/idlelib/IOBinding.py

   1 # changes by dscherer@cmu.edu
   2 #   - IOBinding.open() replaces the current window with the opened file,
   3 #     if the current window is both unmodified and unnamed
   4 #   - IOBinding.loadfile() interprets Windows, UNIX, and Macintosh
   5 #     end-of-line conventions, instead of relying on the standard library,
   6 #     which will only understand the local convention.
   7
   8 import os
   9 import tempfile
  10 import tkFileDialog
  11 import tkMessageBox
  12 import re
  13 from configHandler import idleConf
  14
  15 #$ event <<open-window-from-file>>
  16 #$ win <Control-o>
  17 #$ unix <Control-x><Control-f>
  18
  19 #$ event <<save-window>>
  20 #$ win <Control-s>
  21 #$ unix <Control-x><Control-s>
  22
  23 #$ event <<save-window-as-file>>
  24 #$ win <Alt-s>
  25 #$ unix <Control-x><Control-w>
  26
  27 #$ event <<print-window>>
  28 #$ win <Control-p>
  29 #$ unix <Control-x><Control-p>
  30
  31 #$ event <<save-copy-of-window-as-file>>
  32 #$ win <Alt-Shift-s>
  33 #$ unix <Control-x><w>
  34
  35
  36 class IOBinding:
  37
  38     def __init__(self, editwin):
  39         self.editwin = editwin
  40         self.text = editwin.text
  41         self.__id_open = self.text.bind("<<open-window-from-file>>", self.open)
  42         self.__id_save = self.text.bind("<<save-window>>", self.save)
  43         self.__id_saveas = self.text.bind("<<save-window-as-file>>",
  44                                           self.save_as)
  45         self.__id_savecopy = self.text.bind("<<save-copy-of-window-as-file>>",
  46                                             self.save_a_copy)
  47         self.__id_print = self.text.bind("<<print-window>>", self.print_window)
  48
  49     def close(self):
  50         # Undo command bindings
  51         self.text.unbind("<<open-window-from-file>>", self.__id_open)
  52         self.text.unbind("<<save-window>>", self.__id_save)
  53         self.text.unbind("<<save-window-as-file>>",self.__id_saveas)
  54         self.text.unbind("<<save-copy-of-window-as-file>>", self.__id_savecopy)
  55         self.text.unbind("<<print-window>>", self.__id_print)
  56         # Break cycles
  57         self.editwin = None
  58         self.text = None
  59         self.filename_change_hook = None
  60
  61     def get_saved(self):
  62         return self.editwin.get_saved()
  63
  64     def set_saved(self, flag):
  65         self.editwin.set_saved(flag)
  66
  67     def reset_undo(self):
  68         self.editwin.reset_undo()
  69
  70     filename_change_hook = None
  71
  72     def set_filename_change_hook(self, hook):
  73         self.filename_change_hook = hook
  74
  75     filename = None
  76
  77     def set_filename(self, filename):
  78         self.filename = filename
  79         self.set_saved(1)
  80         if self.filename_change_hook:
  81             self.filename_change_hook()
  82
  83     def open(self, event=None, editFile=None):
  84         if self.editwin.flist:
  85             if not editFile:
  86                 filename = self.askopenfile()
  87             else:
  88                 filename=editFile
  89             if filename:
  90                 # If the current window has no filename and hasn't been
  91                 # modified, we replace its contents (no loss).  Otherwise
  92                 # we open a new window.  But we won't replace the
  93                 # shell window (which has an interp(reter) attribute), which
  94                 # gets set to "not modified" at every new prompt.
  95                 try:
  96                     interp = self.editwin.interp
  97                 except:
  98                     interp = None
  99                 if not self.filename and self.get_saved() and not interp:
 100                     self.editwin.flist.open(filename, self.loadfile)
 101                 else:
 102                     self.editwin.flist.open(filename)
 103             else:
 104                 self.text.focus_set()
 105             return "break"
 106         #
 107         # Code for use outside IDLE:
 108         if self.get_saved():
 109             reply = self.maybesave()
 110             if reply == "cancel":
 111                 self.text.focus_set()
 112                 return "break"
 113         if not editFile:
 114             filename = self.askopenfile()
 115         else:
 116             filename=editFile
 117         if filename:
 118             self.loadfile(filename)
 119         else:
 120             self.text.focus_set()
 121         return "break"
 122
 123     def loadfile(self, filename):
 124         try:
 125             # open the file in binary mode so that we can handle
 126             #   end-of-line convention ourselves.
 127             f = open(filename,'rb')
 128             chars = f.read()
 129             f.close()
 130         except IOError, msg:
 131             tkMessageBox.showerror("I/O Error", str(msg), master=self.text)
 132             return 0
 133
 134         # We now convert all end-of-lines to '\n's
 135         eol = r"(\r\n)|\n|\r"  # \r\n (Windows), \n (UNIX), or \r (Mac)
 136         chars = re.compile( eol ).sub( r"\n", chars )
 137
 138         self.text.delete("1.0", "end")
 139         self.set_filename(None)
 140         self.text.insert("1.0", chars)
 141         self.reset_undo()
 142         self.set_filename(filename)
 143         self.text.mark_set("insert", "1.0")
 144         self.text.see("insert")
 145         return 1
 146
 147     def maybesave(self):
 148         if self.get_saved():
 149             return "yes"
 150         message = "Do you want to save %s before closing?" % (
 151             self.filename or "this untitled document")
 152         m = tkMessageBox.Message(
 153             title="Save On Close",
 154             message=message,
 155             icon=tkMessageBox.QUESTION,
 156             type=tkMessageBox.YESNOCANCEL,
 157             master=self.text)
 158         reply = m.show()
 159         if reply == "yes":
 160             self.save(None)
 161             if not self.get_saved():
 162                 reply = "cancel"
 163         self.text.focus_set()
 164         return reply
 165
 166     def save(self, event):
 167         if not self.filename:
 168             self.save_as(event)
 169         else:
 170             if self.writefile(self.filename):
 171                 self.set_saved(1)
 172         self.text.focus_set()
 173         return "break"
 174
 175     def save_as(self, event):
 176         filename = self.asksavefile()
 177         if filename:
 178             if self.writefile(filename):
 179                 self.set_filename(filename)
 180                 self.set_saved(1)
 181         self.text.focus_set()
 182         return "break"
 183
 184     def save_a_copy(self, event):
 185         filename = self.asksavefile()
 186         if filename:
 187             self.writefile(filename)
 188         self.text.focus_set()
 189         return "break"
 190
 191     def writefile(self, filename):
 192         self.fixlastline()
 193         try:
 194             f = open(filename, "w")
 195             chars = str(self.text.get("1.0", "end-1c"))
 196             f.write(chars)
 197             f.close()
 198             ## print "saved to", `filename`
 199             return 1
 200         except IOError, msg:
 201             tkMessageBox.showerror("I/O Error", str(msg),
 202                                    master=self.text)
 203             return 0
 204
 205     def print_window(self, event):
 206         tempfilename = None
 207         if self.get_saved():
 208             filename = self.filename
 209         else:
 210             filename = tempfilename = tempfile.mktemp()
 211             if not self.writefile(filename):
 212                 os.unlink(tempfilename)
 213                 return "break"
 214         platform=os.name
 215         printPlatform=1
 216         if platform == 'posix': #posix platform
 217             command = idleConf.GetOption('main','General','print-command-posix')
 218             command = command + " 2>&1"
 219         elif platform == 'nt': #win32 platform
 220             command = idleConf.GetOption('main','General','print-command-win')
 221         else: #no printing for this platform
 222             printPlatform=0
 223         if printPlatform:  #we can try to print for this platform
 224             command = command % filename
 225             pipe = os.popen(command, "r")
 226             output = pipe.read().strip()
 227             status = pipe.close()
 228             if status:
 229                 output = "Printing failed (exit status 0x%x)\n" % status + output
 230             if output:
 231                 output = "Printing command: %s\n" % repr(command) + output
 232                 tkMessageBox.showerror("Print status", output, master=self.text)
 233         else:  #no printing for this platform
 234             message="Printing is not enabled for this platform: %s" % platform
 235             tkMessageBox.showinfo("Print status", message, master=self.text)
 236         return "break"
 237
 238     def fixlastline(self):
 239         c = self.text.get("end-2c")
 240         if c != '\n':
 241             self.text.insert("end-1c", "\n")
 242
 243     opendialog = None
 244     savedialog = None
 245
 246     filetypes = [
 247         ("Python and text files", "*.py *.pyw *.txt", "TEXT"),
 248         ("All text files", "*", "TEXT"),
 249         ("All files", "*"),
 250         ]
 251
 252     def askopenfile(self):
 253         dir, base = self.defaultfilename("open")
 254         if not self.opendialog:
 255             self.opendialog = tkFileDialog.Open(master=self.text,
 256                                                 filetypes=self.filetypes)
 257         return self.opendialog.show(initialdir=dir, initialfile=base)
 258
 259     def defaultfilename(self, mode="open"):
 260         if self.filename:
 261             return os.path.split(self.filename)
 262         else:
 263             try:
 264                 pwd = os.getcwd()
 265             except os.error:
 266                 pwd = ""
 267             return pwd, ""
 268
 269     def asksavefile(self):
 270         dir, base = self.defaultfilename("save")
 271         if not self.savedialog:
 272             self.savedialog = tkFileDialog.SaveAs(master=self.text,
 273                                                   filetypes=self.filetypes)
 274         return self.savedialog.show(initialdir=dir, initialfile=base)
 275
 276
 277 def test():
 278     root = Tk()
 279     class MyEditWin:
 280         def __init__(self, text):
 281             self.text = text
 282             self.flist = None
 283             self.text.bind("<Control-o>", self.open)
 284             self.text.bind("<Control-s>", self.save)
 285             self.text.bind("<Alt-s>", self.save_as)
 286             self.text.bind("<Alt-z>", self.save_a_copy)
 287         def get_saved(self): return 0
 288         def set_saved(self, flag): pass
 289         def reset_undo(self): pass
 290         def open(self, event):
 291             self.text.event_generate("<<open-window-from-file>>")
 292         def save(self, event):
 293             self.text.event_generate("<<save-window>>")
 294         def save_as(self, event):
 295             self.text.event_generate("<<save-window-as-file>>")
 296         def save_a_copy(self, event):
 297             self.text.event_generate("<<save-copy-of-window-as-file>>")
 298     text = Text(root)
 299     text.pack()
 300     text.focus_set()
 301     editwin = MyEditWin(text)
 302     io = IOBinding(editwin)
 303     root.mainloop()
 304
 305 if __name__ == "__main__":
 306     from Tkinter import *
 307     test()