import string from Tkinter import TclError import tkMessageBox import tkSimpleDialog # The default tab setting for a Text widget, in average-width characters. TK_TABWIDTH_DEFAULT = 8 ###$ event <> ###$ win ###$ win ###$ unix ###$ unix ###$ event <> ###$ win ###$ unix ###$ unix ###$ event <> ###$ win ###$ unix ###$ unix ###$ event <> ###$ win ###$ unix ###$ event <> ###$ win ###$ unix ###$ event <> ###$ win ###$ unix ###$ event <> ###$ win ###$ unix import re _is_block_closer = re.compile(r""" \s* ( return | break | continue | raise | pass ) \b """, re.VERBOSE).match # colon followed by optional comment _looks_like_opener = re.compile(r":\s*(#.*)?$").search del re class AutoIndent: menudefs = [ ('edit', [ None, ('_Indent region', '<>'), ('_Dedent region', '<>'), ('Comment _out region', '<>'), ('U_ncomment region', '<>'), ('Tabify region', '<>'), ('Untabify region', '<>'), ('Toggle tabs', '<>'), ('New tab width', '<>'), ('New indent width', '<>'), ]), ] keydefs = { '<>': [''], '<>': ['', ''], '<>': [''] } windows_keydefs = { '<>': [''], '<>': [''], '<>': [''], '<>': [''], '<>': [''], '<>': [''], '<>': [''], '<>': [''], '<>': [''], } unix_keydefs = { '<>': ['', '', ''], '<>': ['', '', ''], '<>': ['', ''], '<>': ['', ''], '<>': ['', ''], '<>': ['', ''], } # usetabs true -> literal tab characters are used by indent and # dedent cmds, possibly mixed with spaces if # indentwidth is not a multiple of tabwidth # false -> tab characters are converted to spaces by indent # and dedent cmds, and ditto TAB keystrokes # indentwidth is the number of characters per logical indent level # tabwidth is the display width of a literal tab character usetabs = 0 indentwidth = 4 tabwidth = 8 def __init__(self, editwin): self.text = editwin.text def config(self, **options): for key, value in options.items(): if key == 'usetabs': self.usetabs = value elif key == 'indentwidth': self.indentwidth = value elif key == 'tabwidth': self.tabwidth = value else: raise KeyError, "bad option name: %s" % `key` # If ispythonsource and guess are true, guess a good value for # indentwidth based on file content (if possible), and if # indentwidth != tabwidth set usetabs false. # In any case, adjust the Text widget's view of what a tab # character means. def set_indentation_params(self, ispythonsource, guess=1): text = self.text if guess and ispythonsource: i = self.guess_indent() ##import sys ##sys.__stdout__.write("indent %d\n" % i) if 2 <= i <= 8: self.indentwidth = i if self.indentwidth != self.tabwidth: self.usetabs = 0 current_tabs = text['tabs'] if current_tabs == "" and self.tabwidth == TK_TABWIDTH_DEFAULT: pass else: # Reconfigure the Text widget by measuring the width # of a tabwidth-length string in pixels, forcing the # widget's tab stops to that. need_tabs = text.tk.call("font", "measure", text['font'], "-displayof", text.master, "n" * self.tabwidth) if current_tabs != need_tabs: text.configure(tabs=need_tabs) def smart_backspace_event(self, event): text = self.text try: first = text.index("sel.first") last = text.index("sel.last") except TclError: first = last = None if first and last: text.delete(first, last) text.mark_set("insert", first) return "break" # If we're at the end of leading whitespace, nuke one indent # level, else one character. chars = text.get("insert linestart", "insert") raw, effective = classifyws(chars, self.tabwidth) if 0 < raw == len(chars): if effective >= self.indentwidth: self.reindent_to(effective - self.indentwidth) return "break" text.delete("insert-1c") return "break" def smart_indent_event(self, event): # if intraline selection: # delete it # elif multiline selection: # do indent-region & return # indent one level text = self.text try: first = text.index("sel.first") last = text.index("sel.last") except TclError: first = last = None text.undo_block_start() try: if first and last: if index2line(first) != index2line(last): return self.indent_region_event(event) text.delete(first, last) text.mark_set("insert", first) prefix = text.get("insert linestart", "insert") raw, effective = classifyws(prefix, self.tabwidth) if raw == len(prefix): # only whitespace to the left self.reindent_to(effective + self.indentwidth) else: if self.usetabs: pad = '\t' else: effective = len(string.expandtabs(prefix, self.tabwidth)) n = self.indentwidth pad = ' ' * (n - effective % n) text.insert("insert", pad) text.see("insert") return "break" finally: text.undo_block_stop() def newline_and_indent_event(self, event): text = self.text try: first = text.index("sel.first") last = text.index("sel.last") except TclError: first = last = None text.undo_block_start() try: if first and last: text.delete(first, last) text.mark_set("insert", first) line = text.get("insert linestart", "insert") i, n = 0, len(line) while i < n and line[i] in " \t": i = i+1 indent = line[:i] # strip trailing whitespace i = 0 while line and line[-1] in " \t": line = line[:-1] i = i + 1 if i: text.delete("insert - %d chars" % i, "insert") # XXX this reproduces the current line's indentation, # without regard for usetabs etc; could instead insert # "\n" + self._make_blanks(classifyws(indent)[1]). text.insert("insert", "\n" + indent) if _is_block_opener(line): self.smart_indent_event(event) elif indent and _is_block_closer(line) and line[-1] != "\\": self.smart_backspace_event(event) text.see("insert") return "break" finally: text.undo_block_stop() auto_indent = newline_and_indent_event def indent_region_event(self, event): head, tail, chars, lines = self.get_region() for pos in range(len(lines)): line = lines[pos] if line: raw, effective = classifyws(line, self.tabwidth) effective = effective + self.indentwidth lines[pos] = self._make_blanks(effective) + line[raw:] self.set_region(head, tail, chars, lines) return "break" def dedent_region_event(self, event): head, tail, chars, lines = self.get_region() for pos in range(len(lines)): line = lines[pos] if line: raw, effective = classifyws(line, self.tabwidth) effective = max(effective - self.indentwidth, 0) lines[pos] = self._make_blanks(effective) + line[raw:] self.set_region(head, tail, chars, lines) return "break" def comment_region_event(self, event): head, tail, chars, lines = self.get_region() for pos in range(len(lines)): line = lines[pos] if line: lines[pos] = '##' + line self.set_region(head, tail, chars, lines) def uncomment_region_event(self, event): head, tail, chars, lines = self.get_region() for pos in range(len(lines)): line = lines[pos] if not line: continue if line[:2] == '##': line = line[2:] elif line[:1] == '#': line = line[1:] lines[pos] = line self.set_region(head, tail, chars, lines) def tabify_region_event(self, event): head, tail, chars, lines = self.get_region() for pos in range(len(lines)): line = lines[pos] if line: raw, effective = classifyws(line, self.tabwidth) ntabs, nspaces = divmod(effective, self.tabwidth) lines[pos] = '\t' * ntabs + ' ' * nspaces + line[raw:] self.set_region(head, tail, chars, lines) def untabify_region_event(self, event): head, tail, chars, lines = self.get_region() for pos in range(len(lines)): lines[pos] = string.expandtabs(lines[pos], self.tabwidth) self.set_region(head, tail, chars, lines) def toggle_tabs_event(self, event): if tkMessageBox.askyesno("Toggle tabs", "Turn tabs " + ("on", "off")[self.usetabs] + "?", parent=self.text): self.usetabs = not self.usetabs return "break" def change_tabwidth_event(self, event): new = tkSimpleDialog.askinteger("Tab width", "New tab width (2-16)", parent=self.text, initialvalue=self.tabwidth, minvalue=2, maxvalue=16) if new and new != self.tabwidth: self.tabwidth = new self.set_indentation_params(0, guess=0) return "break" def change_indentwidth_event(self, event): new = tkSimpleDialog.askinteger("Indent width", "New indent width (1-16)", parent=self.text, initialvalue=self.indentwidth, minvalue=1, maxvalue=16) if new and new != self.indentwidth: self.indentwidth = new return "break" def get_region(self): text = self.text head = text.index("sel.first linestart") tail = text.index("sel.last -1c lineend +1c") if not (head and tail): head = text.index("insert linestart") tail = text.index("insert lineend +1c") chars = text.get(head, tail) lines = string.split(chars, "\n") return head, tail, chars, lines def set_region(self, head, tail, chars, lines): text = self.text newchars = string.join(lines, "\n") if newchars == chars: text.bell() return text.tag_remove("sel", "1.0", "end") text.mark_set("insert", head) text.undo_block_start() text.delete(head, tail) text.insert(head, newchars) text.undo_block_stop() text.tag_add("sel", head, "insert") # Make string that displays as n leading blanks. def _make_blanks(self, n): if self.usetabs: ntabs, nspaces = divmod(n, self.tabwidth) return '\t' * ntabs + ' ' * nspaces else: return ' ' * n # Delete from beginning of line to insert point, then reinsert # column logical (meaning use tabs if appropriate) spaces. def reindent_to(self, column): text = self.text text.undo_block_start() text.delete("insert linestart", "insert") if column: text.insert("insert", self._make_blanks(column)) text.undo_block_stop() # Guess indentwidth from text content. # Return guessed indentwidth. This should not be believed unless # it's in a reasonable range (e.g., it will be 0 if no indented # blocks are found). def guess_indent(self): opener, indented = IndentSearcher(self.text, self.tabwidth).run() if opener and indented: raw, indentsmall = classifyws(opener, self.tabwidth) raw, indentlarge = classifyws(indented, self.tabwidth) else: indentsmall = indentlarge = 0 return indentlarge - indentsmall # "line.col" -> line, as an int def index2line(index): return int(float(index)) # Look at the leading whitespace in s. # Return pair (# of leading ws characters, # effective # of leading blanks after expanding # tabs to width tabwidth) def classifyws(s, tabwidth): raw = effective = 0 for ch in s: if ch == ' ': raw = raw + 1 effective = effective + 1 elif ch == '\t': raw = raw + 1 effective = (effective / tabwidth + 1) * tabwidth else: break return raw, effective # Return true iff line probably opens a block. This is a limited # analysis based on whether the line's last "interesting" character # is a colon. def _is_block_opener(line): if not _looks_like_opener(line): return 0 # Looks like an opener, but possible we're in a comment # x = 3 # and then: # or a string # x = ":#" # If no comment character, we're not in a comment , and the # colon is the last non-ws char on the line so it's not in a # (single-line) string either. if string.find(line, '#') < 0: return 1 # Now it's hard: There's a colon and a comment char. Brute force # approximation. lastch, i, n = 0, 0, len(line) while i < n: ch = line[i] if ch == '\\': lastch = ch i = i+2 elif ch in "\"'": # consume string w = 1 # width of string quote if line[i:i+3] in ('"""', "'''"): w = 3 ch = ch * 3 i = i+w while i < n: if line[i] == '\\': i = i+2 elif line[i:i+w] == ch: i = i+w break else: i = i+1 lastch = ch elif ch == '#': break else: if ch not in string.whitespace: lastch = ch i = i+1 return lastch == ':' import tokenize _tokenize = tokenize del tokenize class IndentSearcher: # .run() chews over the Text widget, looking for a block opener # and the stmt following it. Returns a pair, # (line containing block opener, line containing stmt) # Either or both may be None. def __init__(self, text, tabwidth): self.text = text self.tabwidth = tabwidth self.i = self.finished = 0 self.blkopenline = self.indentedline = None def readline(self): if self.finished: return "" i = self.i = self.i + 1 mark = `i` + ".0" if self.text.compare(mark, ">=", "end"): return "" return self.text.get(mark, mark + " lineend+1c") def tokeneater(self, type, token, start, end, line, INDENT=_tokenize.INDENT, NAME=_tokenize.NAME, OPENERS=('class', 'def', 'for', 'if', 'try', 'while')): if self.finished: pass elif type == NAME and token in OPENERS: self.blkopenline = line elif type == INDENT and self.blkopenline: self.indentedline = line self.finished = 1 def run(self): save_tabsize = _tokenize.tabsize _tokenize.tabsize = self.tabwidth try: try: _tokenize.tokenize(self.readline, self.tokeneater) except _tokenize.TokenError: # since we cut off the tokenizer early, we can trigger # spurious errors pass finally: _tokenize.tabsize = save_tabsize return self.blkopenline, self.indentedline