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 types
  10 import sys
  11 import codecs
  12 import tempfile
  13 import tkFileDialog
  14 import tkMessageBox
  15 import re
  16 from Tkinter import *
  17 from SimpleDialog import SimpleDialog
  18
  19 from idlelib.configHandler import idleConf
  20
  21 try:
  22     from codecs import BOM_UTF8
  23 except ImportError:
  24     # only available since Python 2.3
  25     BOM_UTF8 = '\xef\xbb\xbf'
  26
  27 # Try setting the locale, so that we can find out
  28 # what encoding to use
  29 try:
  30     import locale
  31     locale.setlocale(locale.LC_CTYPE, "")
  32 except (ImportError, locale.Error):
  33     pass
  34
  35 # Encoding for file names
  36 filesystemencoding = sys.getfilesystemencoding()
  37
  38 encoding = "ascii"
  39 if sys.platform == 'win32':
  40     # On Windows, we could use "mbcs". However, to give the user
  41     # a portable encoding name, we need to find the code page
  42     try:
  43         encoding = locale.getdefaultlocale()[1]
  44         codecs.lookup(encoding)
  45     except LookupError:
  46         pass
  47 else:
  48     try:
  49         # Different things can fail here: the locale module may not be
  50         # loaded, it may not offer nl_langinfo, or CODESET, or the
  51         # resulting codeset may be unknown to Python. We ignore all
  52         # these problems, falling back to ASCII
  53         encoding = locale.nl_langinfo(locale.CODESET)
  54         if encoding is None or encoding is '':
  55             # situation occurs on Mac OS X
  56             encoding = 'ascii'
  57         codecs.lookup(encoding)
  58     except (NameError, AttributeError, LookupError):
  59         # Try getdefaultlocale well: it parses environment variables,
  60         # which may give a clue. Unfortunately, getdefaultlocale has
  61         # bugs that can cause ValueError.
  62         try:
  63             encoding = locale.getdefaultlocale()[1]
  64             if encoding is None or encoding is '':
  65                 # situation occurs on Mac OS X
  66                 encoding = 'ascii'
  67             codecs.lookup(encoding)
  68         except (ValueError, LookupError):
  69             pass
  70
  71 encoding = encoding.lower()
  72
  73 coding_re = re.compile("coding[:=]\s*([-\w_.]+)")
  74
  75 class EncodingMessage(SimpleDialog):
  76     "Inform user that an encoding declaration is needed."
  77     def __init__(self, master, enc):
  78         self.should_edit = False
  79
  80         self.root = top = Toplevel(master)
  81         top.bind("<Return>", self.return_event)
  82         top.bind("<Escape>", self.do_ok)
  83         top.protocol("WM_DELETE_WINDOW", self.wm_delete_window)
  84         top.wm_title("I/O Warning")
  85         top.wm_iconname("I/O Warning")
  86         self.top = top
  87
  88         l1 = Label(top,
  89             text="Non-ASCII found, yet no encoding declared. Add a line like")
  90         l1.pack(side=TOP, anchor=W)
  91         l2 = Entry(top, font="courier")
  92         l2.insert(0, "# -*- coding: %s -*-" % enc)
  93         # For some reason, the text is not selectable anymore if the
  94         # widget is disabled.
  95         # l2['state'] = DISABLED
  96         l2.pack(side=TOP, anchor = W, fill=X)
  97         l3 = Label(top, text="to your file\n"
  98                    "Choose OK to save this file as %s\n"
  99                    "Edit your general options to silence this warning" % enc)
 100         l3.pack(side=TOP, anchor = W)
 101
 102         buttons = Frame(top)
 103         buttons.pack(side=TOP, fill=X)
 104         # Both return and cancel mean the same thing: do nothing
 105         self.default = self.cancel = 0
 106         b1 = Button(buttons, text="Ok", default="active",
 107                     command=self.do_ok)
 108         b1.pack(side=LEFT, fill=BOTH, expand=1)
 109         b2 = Button(buttons, text="Edit my file",
 110                     command=self.do_edit)
 111         b2.pack(side=LEFT, fill=BOTH, expand=1)
 112
 113         self._set_transient(master)
 114
 115     def do_ok(self):
 116         self.done(0)
 117
 118     def do_edit(self):
 119         self.done(1)
 120
 121 def coding_spec(str):
 122     """Return the encoding declaration according to PEP 263.
 123
 124     Raise LookupError if the encoding is declared but unknown.
 125     """
 126     # Only consider the first two lines
 127     str = str.split("\n")[:2]
 128     str = "\n".join(str)
 129
 130     match = coding_re.search(str)
 131     if not match:
 132         return None
 133     name = match.group(1)
 134     # Check whether the encoding is known
 135     import codecs
 136     try:
 137         codecs.lookup(name)
 138     except LookupError:
 139         # The standard encoding error does not indicate the encoding
 140         raise LookupError, "Unknown encoding "+name
 141     return name
 142
 143
 144 class IOBinding:
 145
 146     def __init__(self, editwin):
 147         self.editwin = editwin
 148         self.text = editwin.text
 149         self.__id_open = self.text.bind("<<open-window-from-file>>", self.open)
 150         self.__id_save = self.text.bind("<<save-window>>", self.save)
 151         self.__id_saveas = self.text.bind("<<save-window-as-file>>",
 152                                           self.save_as)
 153         self.__id_savecopy = self.text.bind("<<save-copy-of-window-as-file>>",
 154                                             self.save_a_copy)
 155         self.fileencoding = None
 156         self.__id_print = self.text.bind("<<print-window>>", self.print_window)
 157
 158     def close(self):
 159         # Undo command bindings
 160         self.text.unbind("<<open-window-from-file>>", self.__id_open)
 161         self.text.unbind("<<save-window>>", self.__id_save)
 162         self.text.unbind("<<save-window-as-file>>",self.__id_saveas)
 163         self.text.unbind("<<save-copy-of-window-as-file>>", self.__id_savecopy)
 164         self.text.unbind("<<print-window>>", self.__id_print)
 165         # Break cycles
 166         self.editwin = None
 167         self.text = None
 168         self.filename_change_hook = None
 169
 170     def get_saved(self):
 171         return self.editwin.get_saved()
 172
 173     def set_saved(self, flag):
 174         self.editwin.set_saved(flag)
 175
 176     def reset_undo(self):
 177         self.editwin.reset_undo()
 178
 179     filename_change_hook = None
 180
 181     def set_filename_change_hook(self, hook):
 182         self.filename_change_hook = hook
 183
 184     filename = None
 185     dirname = None
 186
 187     def set_filename(self, filename):
 188         if filename and os.path.isdir(filename):
 189             self.filename = None
 190             self.dirname = filename
 191         else:
 192             self.filename = filename
 193             self.dirname = None
 194             self.set_saved(1)
 195             if self.filename_change_hook:
 196                 self.filename_change_hook()
 197
 198     def open(self, event=None, editFile=None):
 199         if self.editwin.flist:
 200             if not editFile:
 201                 filename = self.askopenfile()
 202             else:
 203                 filename=editFile
 204             if filename:
 205                 # If the current window has no filename and hasn't been
 206                 # modified, we replace its contents (no loss).  Otherwise
 207                 # we open a new window.  But we won't replace the
 208                 # shell window (which has an interp(reter) attribute), which
 209                 # gets set to "not modified" at every new prompt.
 210                 try:
 211                     interp = self.editwin.interp
 212                 except AttributeError:
 213                     interp = None
 214                 if not self.filename and self.get_saved() and not interp:
 215                     self.editwin.flist.open(filename, self.loadfile)
 216                 else:
 217                     self.editwin.flist.open(filename)
 218             else:
 219                 self.text.focus_set()
 220             return "break"
 221         #
 222         # Code for use outside IDLE:
 223         if self.get_saved():
 224             reply = self.maybesave()
 225             if reply == "cancel":
 226                 self.text.focus_set()
 227                 return "break"
 228         if not editFile:
 229             filename = self.askopenfile()
 230         else:
 231             filename=editFile
 232         if filename:
 233             self.loadfile(filename)
 234         else:
 235             self.text.focus_set()
 236         return "break"
 237
 238     eol = r"(\r\n)|\n|\r"  # \r\n (Windows), \n (UNIX), or \r (Mac)
 239     eol_re = re.compile(eol)
 240     eol_convention = os.linesep # Default
 241
 242     def loadfile(self, filename):
 243         try:
 244             # open the file in binary mode so that we can handle
 245             #   end-of-line convention ourselves.
 246             f = open(filename,'rb')
 247             chars = f.read()
 248             f.close()
 249         except IOError, msg:
 250             tkMessageBox.showerror("I/O Error", str(msg), master=self.text)
 251             return False
 252
 253         chars = self.decode(chars)
 254         # We now convert all end-of-lines to '\n's
 255         firsteol = self.eol_re.search(chars)
 256         if firsteol:
 257             self.eol_convention = firsteol.group(0)
 258             if isinstance(self.eol_convention, unicode):
 259                 # Make sure it is an ASCII string
 260                 self.eol_convention = self.eol_convention.encode("ascii")
 261             chars = self.eol_re.sub(r"\n", chars)
 262
 263         self.text.delete("1.0", "end")
 264         self.set_filename(None)
 265         self.text.insert("1.0", chars)
 266         self.reset_undo()
 267         self.set_filename(filename)
 268         self.text.mark_set("insert", "1.0")
 269         self.text.see("insert")
 270         self.updaterecentfileslist(filename)
 271         return True
 272
 273     def decode(self, chars):
 274         """Create a Unicode string
 275
 276         If that fails, let Tcl try its best
 277         """
 278         # Check presence of a UTF-8 signature first
 279         if chars.startswith(BOM_UTF8):
 280             try:
 281                 chars = chars[3:].decode("utf-8")
 282             except UnicodeError:
 283                 # has UTF-8 signature, but fails to decode...
 284                 return chars
 285             else:
 286                 # Indicates that this file originally had a BOM
 287                 self.fileencoding = BOM_UTF8
 288                 return chars
 289         # Next look for coding specification
 290         try:
 291             enc = coding_spec(chars)
 292         except LookupError, name:
 293             tkMessageBox.showerror(
 294                 title="Error loading the file",
 295                 message="The encoding '%s' is not known to this Python "\
 296                 "installation. The file may not display correctly" % name,
 297                 master = self.text)
 298             enc = None
 299         if enc:
 300             try:
 301                 return unicode(chars, enc)
 302             except UnicodeError:
 303                 pass
 304         # If it is ASCII, we need not to record anything
 305         try:
 306             return unicode(chars, 'ascii')
 307         except UnicodeError:
 308             pass
 309         # Finally, try the locale's encoding. This is deprecated;
 310         # the user should declare a non-ASCII encoding
 311         try:
 312             chars = unicode(chars, encoding)
 313             self.fileencoding = encoding
 314         except UnicodeError:
 315             pass
 316         return chars
 317
 318     def maybesave(self):
 319         if self.get_saved():
 320             return "yes"
 321         message = "Do you want to save %s before closing?" % (
 322             self.filename or "this untitled document")
 323         m = tkMessageBox.Message(
 324             title="Save On Close",
 325             message=message,
 326             icon=tkMessageBox.QUESTION,
 327             type=tkMessageBox.YESNOCANCEL,
 328             master=self.text)
 329         reply = m.show()
 330         if reply == "yes":
 331             self.save(None)
 332             if not self.get_saved():
 333                 reply = "cancel"
 334         self.text.focus_set()
 335         return reply
 336
 337     def save(self, event):
 338         if not self.filename:
 339             self.save_as(event)
 340         else:
 341             if self.writefile(self.filename):
 342                 self.set_saved(1)
 343                 try:
 344                     self.editwin.store_file_breaks()
 345                 except AttributeError:  # may be a PyShell
 346                     pass
 347         self.text.focus_set()
 348         return "break"
 349
 350     def save_as(self, event):
 351         filename = self.asksavefile()
 352         if filename:
 353             if self.writefile(filename):
 354                 self.set_filename(filename)
 355                 self.set_saved(1)
 356                 try:
 357                     self.editwin.store_file_breaks()
 358                 except AttributeError:
 359                     pass
 360         self.text.focus_set()
 361         self.updaterecentfileslist(filename)
 362         return "break"
 363
 364     def save_a_copy(self, event):
 365         filename = self.asksavefile()
 366         if filename:
 367             self.writefile(filename)
 368         self.text.focus_set()
 369         self.updaterecentfileslist(filename)
 370         return "break"
 371
 372     def writefile(self, filename):
 373         self.fixlastline()
 374         chars = self.encode(self.text.get("1.0", "end-1c"))
 375         if self.eol_convention != "\n":
 376             chars = chars.replace("\n", self.eol_convention)
 377         try:
 378             f = open(filename, "wb")
 379             f.write(chars)
 380             f.flush()
 381             f.close()
 382             return True
 383         except IOError, msg:
 384             tkMessageBox.showerror("I/O Error", str(msg),
 385                                    master=self.text)
 386             return False
 387
 388     def encode(self, chars):
 389         if isinstance(chars, types.StringType):
 390             # This is either plain ASCII, or Tk was returning mixed-encoding
 391             # text to us. Don't try to guess further.
 392             return chars
 393         # See whether there is anything non-ASCII in it.
 394         # If not, no need to figure out the encoding.
 395         try:
 396             return chars.encode('ascii')
 397         except UnicodeError:
 398             pass
 399         # If there is an encoding declared, try this first.
 400         try:
 401             enc = coding_spec(chars)
 402             failed = None
 403         except LookupError, msg:
 404             failed = msg
 405             enc = None
 406         if enc:
 407             try:
 408                 return chars.encode(enc)
 409             except UnicodeError:
 410                 failed = "Invalid encoding '%s'" % enc
 411         if failed:
 412             tkMessageBox.showerror(
 413                 "I/O Error",
 414                 "%s. Saving as UTF-8" % failed,
 415                 master = self.text)
 416         # If there was a UTF-8 signature, use that. This should not fail
 417         if self.fileencoding == BOM_UTF8 or failed:
 418             return BOM_UTF8 + chars.encode("utf-8")
 419         # Try the original file encoding next, if any
 420         if self.fileencoding:
 421             try:
 422                 return chars.encode(self.fileencoding)
 423             except UnicodeError:
 424                 tkMessageBox.showerror(
 425                     "I/O Error",
 426                     "Cannot save this as '%s' anymore. Saving as UTF-8" \
 427                     % self.fileencoding,
 428                     master = self.text)
 429                 return BOM_UTF8 + chars.encode("utf-8")
 430         # Nothing was declared, and we had not determined an encoding
 431         # on loading. Recommend an encoding line.
 432         config_encoding = idleConf.GetOption("main","EditorWindow",
 433                                              "encoding")
 434         if config_encoding == 'utf-8':
 435             # User has requested that we save files as UTF-8
 436             return BOM_UTF8 + chars.encode("utf-8")
 437         ask_user = True
 438         try:
 439             chars = chars.encode(encoding)
 440             enc = encoding
 441             if config_encoding == 'locale':
 442                 ask_user = False
 443         except UnicodeError:
 444             chars = BOM_UTF8 + chars.encode("utf-8")
 445             enc = "utf-8"
 446         if not ask_user:
 447             return chars
 448         dialog = EncodingMessage(self.editwin.top, enc)
 449         dialog.go()
 450         if dialog.num == 1:
 451             # User asked us to edit the file
 452             encline = "# -*- coding: %s -*-\n" % enc
 453             firstline = self.text.get("1.0", "2.0")
 454             if firstline.startswith("#!"):
 455                 # Insert encoding after #! line
 456                 self.text.insert("2.0", encline)
 457             else:
 458                 self.text.insert("1.0", encline)
 459             return self.encode(self.text.get("1.0", "end-1c"))
 460         return chars
 461
 462     def fixlastline(self):
 463         c = self.text.get("end-2c")
 464         if c != '\n':
 465             self.text.insert("end-1c", "\n")
 466
 467     def print_window(self, event):
 468         m = tkMessageBox.Message(
 469             title="Print",
 470             message="Print to Default Printer",
 471             icon=tkMessageBox.QUESTION,
 472             type=tkMessageBox.OKCANCEL,
 473             default=tkMessageBox.OK,
 474             master=self.text)
 475         reply = m.show()
 476         if reply != tkMessageBox.OK:
 477             self.text.focus_set()
 478             return "break"
 479         tempfilename = None
 480         saved = self.get_saved()
 481         if saved:
 482             filename = self.filename
 483         # shell undo is reset after every prompt, looks saved, probably isn't
 484         if not saved or filename is None:
 485             (tfd, tempfilename) = tempfile.mkstemp(prefix='IDLE_tmp_')
 486             filename = tempfilename
 487             os.close(tfd)
 488             if not self.writefile(tempfilename):
 489                 os.unlink(tempfilename)
 490                 return "break"
 491         platform=os.name
 492         printPlatform=1
 493         if platform == 'posix': #posix platform
 494             command = idleConf.GetOption('main','General',
 495                                          'print-command-posix')
 496             command = command + " 2>&1"
 497         elif platform == 'nt': #win32 platform
 498             command = idleConf.GetOption('main','General','print-command-win')
 499         else: #no printing for this platform
 500             printPlatform=0
 501         if printPlatform:  #we can try to print for this platform
 502             command = command % filename
 503             pipe = os.popen(command, "r")
 504             # things can get ugly on NT if there is no printer available.
 505             output = pipe.read().strip()
 506             status = pipe.close()
 507             if status:
 508                 output = "Printing failed (exit status 0x%x)\n" % \
 509                          status + output
 510             if output:
 511                 output = "Printing command: %s\n" % repr(command) + output
 512                 tkMessageBox.showerror("Print status", output, master=self.text)
 513         else:  #no printing for this platform
 514             message="Printing is not enabled for this platform: %s" % platform
 515             tkMessageBox.showinfo("Print status", message, master=self.text)
 516         if tempfilename:
 517             os.unlink(tempfilename)
 518         return "break"
 519
 520     opendialog = None
 521     savedialog = None
 522
 523     filetypes = [
 524         ("Python and text files", "*.py *.pyw *.txt", "TEXT"),
 525         ("All text files", "*", "TEXT"),
 526         ("All files", "*"),
 527         ]
 528
 529     def askopenfile(self):
 530         dir, base = self.defaultfilename("open")
 531         if not self.opendialog:
 532             self.opendialog = tkFileDialog.Open(master=self.text,
 533                                                 filetypes=self.filetypes)
 534         filename = self.opendialog.show(initialdir=dir, initialfile=base)
 535         if isinstance(filename, unicode):
 536             filename = filename.encode(filesystemencoding)
 537         return filename
 538
 539     def defaultfilename(self, mode="open"):
 540         if self.filename:
 541             return os.path.split(self.filename)
 542         elif self.dirname:
 543             return self.dirname, ""
 544         else:
 545             try:
 546                 pwd = os.getcwd()
 547             except os.error:
 548                 pwd = ""
 549             return pwd, ""
 550
 551     def asksavefile(self):
 552         dir, base = self.defaultfilename("save")
 553         if not self.savedialog:
 554             self.savedialog = tkFileDialog.SaveAs(master=self.text,
 555                                                   filetypes=self.filetypes)
 556         filename = self.savedialog.show(initialdir=dir, initialfile=base)
 557         if isinstance(filename, unicode):
 558             filename = filename.encode(filesystemencoding)
 559         return filename
 560
 561     def updaterecentfileslist(self,filename):
 562         "Update recent file list on all editor windows"
 563         self.editwin.update_recent_files_list(filename)
 564
 565 def test():
 566     root = Tk()
 567     class MyEditWin:
 568         def __init__(self, text):
 569             self.text = text
 570             self.flist = None
 571             self.text.bind("<Control-o>", self.open)
 572             self.text.bind("<Control-s>", self.save)
 573             self.text.bind("<Alt-s>", self.save_as)
 574             self.text.bind("<Alt-z>", self.save_a_copy)
 575         def get_saved(self): return 0
 576         def set_saved(self, flag): pass
 577         def reset_undo(self): pass
 578         def open(self, event):
 579             self.text.event_generate("<<open-window-from-file>>")
 580         def save(self, event):
 581             self.text.event_generate("<<save-window>>")
 582         def save_as(self, event):
 583             self.text.event_generate("<<save-window-as-file>>")
 584         def save_a_copy(self, event):
 585             self.text.event_generate("<<save-copy-of-window-as-file>>")
 586     text = Text(root)
 587     text.pack()
 588     text.focus_set()
 589     editwin = MyEditWin(text)
 590     io = IOBinding(editwin)
 591     root.mainloop()
 592
 593 if __name__ == "__main__":
 594     test()