From e8f015574c983dcdeb5e8d0649605179a912196b Mon Sep 17 00:00:00 2001 From: moculus Date: Thu, 14 Jun 2007 12:41:55 +0000 Subject: [PATCH] sort of for real --HG-- branch : pmacs2 --- application.py | 4 +- bufferlist.py | 5 - highlight2.py | 1 - method.py | 242 +++++++++++++++++++++++++----------------------- mode_replace.py | 86 +++++++++-------- window2.py | 40 ++++++-- 6 files changed, 204 insertions(+), 174 deletions(-) diff --git a/application.py b/application.py index 3dfbe42..4c47715 100755 --- a/application.py +++ b/application.py @@ -87,7 +87,7 @@ class Application(object): # 'nasm': mode_nasm.Nasm, 'perl': mode_perl.Perl, 'python': mode_python.Python, -# 'replace': mode_replace.Replace, + 'replace': mode_replace.Replace, 'search': mode_search.Search, # 'sh': mode_sh.Sh, # 'text': mode_text.Text, @@ -211,7 +211,7 @@ class Application(object): assert n >= 0 and n < len(self.bufferlist.slots), \ "invalid slot: %r (%r)" % (n, len(self.bufferlist.slots)) self.bufferlist.remove_slot(n) - if self.active_slot > slotname: + if self.active_slot > n: self.active_slot = max(0, self.active_slot - 1) #XYZ def single_slot(self): while len(self.bufferlist.slots) > 1: diff --git a/bufferlist.py b/bufferlist.py index 17412d3..ee8bcb0 100644 --- a/bufferlist.py +++ b/bufferlist.py @@ -67,16 +67,13 @@ class BufferList: # manipulate slots def add_slot(self): - assert len(self.slots) == 0, "fuck" self.slots.append(Slot(self.height, self.width, 0)) self.fit_slots() return len(self.slots) - 1 def empty_slot(self, i): - assert len(self.slots) == 0, "fuck" assert i > -1 and i < len(self.slots), "slot %d does not exist" % i return self.slots[i].is_empty() def unset_slot(self, i): - assert len(self.slots) == 1, "fuck" assert i > -1 and i < len(self.slots), "slot %d does not exist" % i old_w = self.slots[i].unset() if old_w is not None: @@ -87,7 +84,6 @@ class BufferList: old_b.remove_window(old_w) def set_slot(self, i, b): - assert len(self.slots) == 1, "fuck" assert i > -1 and i < len(self.slots), "slot %d does not exist" % i assert b in self.buffers, "buffer %s does not exist" % (b.name()) slot = self.slots[i] @@ -103,7 +99,6 @@ class BufferList: slot.set(w) def remove_slot(self, i): - assert False, "fuck" assert i > -1 and i < len(self.slots), "slot %d does not exist" % i self.unset_slot(i) del self.slots[i] diff --git a/highlight2.py b/highlight2.py index b8f007a..f4b702e 100644 --- a/highlight2.py +++ b/highlight2.py @@ -160,7 +160,6 @@ class Highlighter: def update_del(self, lines, y1, x1, y2, x2): assert y1 >= 0 assert y1 <= y2 - assert y2 < len(lines) # first let's delete any token who falls in the range of the change (or, # in the case of child tokens, whose parent is being deleted). diff --git a/method.py b/method.py index 777e6d9..e880fcd 100644 --- a/method.py +++ b/method.py @@ -2,6 +2,8 @@ import os, commands, popen2, re import buffer2, default, regex, util, window2 from point2 import Point +WHITESPACE = [' ', '\n'] + DATATYPES = { "path": None, "buffer": None, @@ -220,7 +222,7 @@ class OpenAesFile(Method): if not w.application.has_buffer_name(path): b = buffer2.AesBuffer(path, password) b.open() - window.Window(b, a, height=0, width=0) + window2.Window(b, a, height=0, width=0) w.application.add_buffer(b) SwitchBuffer().execute(w, buffername=path) class SwitchBuffer(Method): @@ -261,6 +263,10 @@ class KillBuffer(Method): b.close() class ForceKillBuffer(KillBuffer): force=True + def _args(self): + return [Argument('buffername', datatype="buffer", + prompt="Force Kill Buffer: ", + default=default.current_buffer)] class ListBuffers(Method): '''List all open buffers in a new buffer''' def _execute(self, w, **vargs): @@ -284,8 +290,11 @@ class SaveBufferAs(Method): w.application.set_error("buffer for %r is already open" % path) return w.application.file_buffer(path, data, switch_to=True) - w.application.methods['kill-buffer'].execute(w, buffername=curr_buffer_name) - #w.application.set_error('Wrote %r' % path) + if curr_buffer_name != '*Scratch*': + w.application.methods['kill-buffer'].execute(w, buffername=curr_buffer_name) + else: + curr_buffer.set_data('') + w.application.set_error('Wrote %r' % path) class SaveBuffer(Method): '''Save the contents of a buffer''' def _execute(self, w, **vargs): @@ -421,30 +430,28 @@ class DeleteRightWord(Method): class DeleteLeftWhitespace(Method): '''Delete all contiguous of whitespace left of the cursor''' def _execute(self, w, **vargs): - cursor = w.logical_cursor() - cursor_offset = w.get_cursor_offset() - left_offset = cursor_offset - 1 - s = w.buffer.make_string() - while left_offset >= 0 and (s[left_offset] == ' ' or - s[left_offset] == '\n'): - left_offset -= 1 - left_offset += 1 - if left_offset < cursor_offset - 1: - left_point = w.buffer.get_offset_point(left_offset) - w.kill(left_point, cursor) + c = w.logical_cursor() + p = c + l = w.point_left(p) + if l is None: + return + while l is not None and w.point_char(l) in WHITESPACE: + p = l + l = w.point_left(p) + if p < c: + w.kill(p, c) class DeleteRightWhitespace(Method): '''Delete all contiguous of whitespace under and right of the cursor''' def _execute(self, w, **vargs): - cursor = w.logical_cursor() - cursor_offset = w.get_cursor_offset() - right_offset = cursor_offset - s = w.buffer.make_string() - while right_offset < len(s) and (s[right_offset] == ' ' or - s[right_offset] == '\n'): - right_offset += 1 - if right_offset > cursor_offset: - right_point = w.buffer.get_offset_point(right_offset) - w.kill(cursor, right_point) + c = w.logical_cursor() + p = c + while w.point_char(p) in WHITESPACE: + r = w.point_right(p) + if r is None: + break + p = r + if p > c: + w.kill(c, p) # random stuff class DumpTokens(Method): @@ -487,77 +494,78 @@ class ToggleMargins(Method): a.margins_visible = not a.margins_visible class CenterView(Method): '''Move view to center on cursor''' - def _execute(self, window, **vargs): - window.center_view() + def _execute(self, w, **vargs): + w.center_view() class SetMark(Method): '''Set the mark to the current cursor location''' - def _execute(self, window, **vargs): - window.set_mark() + def _execute(self, w, **vargs): + w.set_mark() class SwitchMark(Method): '''Switch the mark and the cursor locations''' - def _execute(self, window, **vargs): - window.switch_mark() + def _execute(self, w, **vargs): + w.switch_mark() # insertion methods class InsertNewline(Method): '''Insert newline into buffer at the cursor''' - def _execute(self, window, **vargs): - window.insert_string_at_cursor('\n') + def _execute(self, w, **vargs): + w.insert_string_at_cursor('\n') class InsertSpace(Method): '''Insert space into buffer at the cursor''' - def _execute(self, window, **vargs): - window.insert_string_at_cursor(' ') + def _execute(self, w, **vargs): + w.insert_string_at_cursor(' ') class InsertTab(Method): '''Insert tab into buffer, or tabbify line, depending on mode''' - def _execute(self, window, **vargs): - cursor = window.logical_cursor() - #i = window.mode.get_indentation_level(cursor.y) + #XYZ + def _execute(self, w, **vargs): + cursor = w.logical_cursor() + #i = w.mode.get_indentation_level(cursor.y) i = None if i is None: - window.insert_string_at_cursor(' ') + w.insert_string_at_cursor(' ') else: - j = window.buffer.count_leading_whitespace(cursor.y) + j = w.buffer.count_leading_whitespace(cursor.y) if i != j: - KillWhitespace().execute(window) - window.insert(Point(0, cursor.y), ' ' * i) + KillWhitespace().execute(w) + w.insert(Point(0, cursor.y), ' ' * i) else: - window.goto(Point(j, cursor.y)) + w.goto(Point(j, cursor.y)) class KillWhitespace(Method): '''Delete leading whitespace on current line''' - def _execute(self, window, **vargs): - cursor = window.logical_cursor() - i = window.buffer.count_leading_whitespace(cursor.y) + def _execute(self, w, **vargs): + cursor = w.logical_cursor() + i = w.buffer.count_leading_whitespace(cursor.y) if i > 0: - window.kill(Point(0, cursor.y), + w.kill(Point(0, cursor.y), Point(i, cursor.y)) # tabification class TabBuffer(Method): '''Tabbify every line in the current buffer''' - def _execute(self, window, **vargs): - y = window.logical_cursor().y + def _execute(self, w, **vargs): + y = w.logical_cursor().y it = InsertTab() - for i in range(0, len(window.buffer.lines)): - window.goto_line(i) - it.execute(window) - window.goto_line(y) + for i in range(0, len(w.buffer.lines)): + w.goto_line(i) + it.execute(w) + w.goto_line(y) # commenting class CommentRegion(Method): '''Prepend a comment to every line in the current buffer''' - def _execute(self, window, **vargs): - cursor = window.logical_cursor() - if cursor < window.mark: + def _execute(self, w, **vargs): + cursor = w.logical_cursor() + if cursor < w.mark: p1 = cursor - p2 = window.mark - elif window.mark < cursor: - p1 = window.mark + p2 = w.mark + elif w.mark < cursor: + p1 = w.mark p2 = cursor else: - window.input_line = "Empty kill region" + w.input_line = "Empty kill region" return for y in range(p1.y, p2.y): - window.buffer.insert_string_at_cursor(Point(0, y), "#") + w.buffer.insert_string_at_cursor(Point(0, y), "#") class UncommentRegion(Method): '''Remove a comment from every line in the current buffer''' def _execute(self, w, **vargs): @@ -579,33 +587,33 @@ class UncommentRegion(Method): class WrapLine(Method): '''Wrap the current line at 80 characters by word''' limit = 80 - def _execute(self, window, **vargs): - cursor = window.logical_cursor() + def _execute(self, w, **vargs): + cursor = w.logical_cursor() old_cursor = cursor.copy() i = cursor.y move_old_cursor = old_cursor.x > self.limit - while len(window.buffer.lines[i]) > self.limit: - if ' ' in window.buffer.lines[i][:self.limit]: - j = window.buffer.lines[i][:self.limit].rindex(' ') - elif ' ' in window.buffer.lines[i][self.limit:]: - j = window.buffer.lines[i][self.limit:].index(' ') + while len(w.buffer.lines[i]) > self.limit: + if ' ' in w.buffer.lines[i][:self.limit]: + j = w.buffer.lines[i][:self.limit].rindex(' ') + elif ' ' in w.buffer.lines[i][self.limit:]: + j = w.buffer.lines[i][self.limit:].index(' ') else: break if move_old_cursor: move_old_cursor = False old_cursor.x -= j + 1 old_cursor.y += 1 - window.goto(Point(j, i)) - window.right_delete() - window.insert_string_at_cursor('\n') + w.goto(Point(j, i)) + w.right_delete() + w.insert_string_at_cursor('\n') i += 1 - l = len(window.buffer.lines[old_cursor.y]) + l = len(w.buffer.lines[old_cursor.y]) if l > old_cursor.x: - window.goto(old_cursor) + w.goto(old_cursor) else: - window.goto(Point(l, old_cursor.y)) + w.goto(Point(l, old_cursor.y)) class WrapParagraph(Method): limit = 80 wrapper = WrapLine @@ -624,11 +632,11 @@ class WrapParagraph(Method): class JustifyRight(Method): '''Justify text with the previous line right from the cursor by whitespace''' - def _execute(self, window, **vargs): - DeleteLeftWhitespace().execute(window) - cursor = window.logical_cursor() - prev_line = window.buffer.lines[cursor.y-1] - this_line = window.buffer.lines[cursor.y] + def _execute(self, w, **vargs): + DeleteLeftWhitespace().execute(w) + cursor = w.logical_cursor() + prev_line = w.buffer.lines[cursor.y-1] + this_line = w.buffer.lines[cursor.y] if cursor.y <= 0: return if cursor.x >= len(prev_line): @@ -643,14 +651,14 @@ class JustifyRight(Method): if i >= len(prev_line): return s = ' ' * (i - cursor.x) - window.insert_string_at_cursor(s) + w.insert_string_at_cursor(s) class JustifyLeft(Method): '''Justify text with the previous line left from the cursor by whitespace''' - def _execute(self, window, **vargs): - DeleteRightWhitespace().execute(window) - cursor = window.logical_cursor() - prev_line = window.buffer.lines[cursor.y-1] - this_line = window.buffer.lines[cursor.y] + def _execute(self, w, **vargs): + DeleteRightWhitespace().execute(w) + cursor = w.logical_cursor() + prev_line = w.buffer.lines[cursor.y-1] + this_line = w.buffer.lines[cursor.y] if cursor.y <= 0: return if cursor.x <= 0: @@ -674,73 +682,73 @@ class JustifyLeft(Method): return if this_line[i] != ' ': return - window.buffer.delete_string(Point(i, cursor.y), cursor) + w.buffer.delete_string(Point(i, cursor.y), cursor) # undo/redo class Undo(Method): '''Undo last action''' - def _execute(self, window, **vargs): + def _execute(self, w, **vargs): try: - window.buffer.undo() + w.buffer.undo() except Exception, e: - window.application.set_error("%s" % (e)) + w.application.set_error("%s" % (e)) class Redo(Method): '''Redo last undone action''' - def _execute(self, window, **vargs): + def _execute(self, w, **vargs): try: - window.buffer.redo() + w.buffer.redo() except Exception, e: - window.application.set_error("%s" % (e)) + w.application.set_error("%s" % (e)) -# window navigation methods +# w navigation methods class StartOfLine(Method): '''Move the cursor to the start of the current line''' - def _execute(self, window, **vargs): - window.start_of_line() + def _execute(self, w, **vargs): + w.start_of_line() class EndOfLine(Method): '''Move the cursor to the end of the current line''' - def _execute(self, window, **vargs): - window.end_of_line() + def _execute(self, w, **vargs): + w.end_of_line() class Forward(Method): '''Move the cursor right one character''' - def _execute(self, window, **vargs): - window.forward() + def _execute(self, w, **vargs): + w.forward() class Backward(Method): '''Move the cursor left one character''' - def _execute(self, window, **vargs): - window.backward() + def _execute(self, w, **vargs): + w.backward() class NextLine(Method): '''Move the cursor down one line''' - def _execute(self, window, **vargs): - window.next_line() + def _execute(self, w, **vargs): + w.next_line() class PreviousLine(Method): '''Move the cursor up one line''' - def _execute(self, window, **vargs): - window.previous_line() + def _execute(self, w, **vargs): + w.previous_line() class PageUp(Method): '''Move the cursor up one page''' - def _execute(self, window, **vargs): - window.page_up() + def _execute(self, w, **vargs): + w.page_up() class PageDown(Method): '''Move the cursor down one page''' - def _execute(self, window, **vargs): - window.page_down() + def _execute(self, w, **vargs): + w.page_down() class GotoBeginning(Method): '''Move the cursor to the beginning of the buffer''' - def _execute(self, window, **vargs): - window.goto_beginning() + def _execute(self, w, **vargs): + w.goto_beginning() class GotoEnd(Method): '''Move the cursor to the end of the buffer''' - def _execute(self, window, **vargs): - window.goto_end() + def _execute(self, w, **vargs): + w.goto_end() class RightWord(Method): '''Move the cursor to the start of the word to the right''' - def _execute(self, window, **vargs): - window.right_word() + def _execute(self, w, **vargs): + w.right_word() class LeftWord(Method): '''Move the cursor to the start of the word to the left''' - def _execute(self, window, **vargs): - window.left_word() + def _execute(self, w, **vargs): + w.left_word() class NextSection(Method): '''Move the cursor to the next section''' def _execute(self, w, **vargs): @@ -862,7 +870,7 @@ class OpenConsole(Method): if not a.has_buffer_name('*Console*'): a.add_buffer(buffer2.ConsoleBuffer()) b = a.bufferlist.get_buffer_by_name('*Console*') - if a.window().buffer is not b: + if a.w().buffer is not b: a.switch_buffer(b) f = lambda x: None w.application.open_mini_buffer('>>> ', f, self, None, 'console') diff --git a/mode_replace.py b/mode_replace.py index c7c6494..20cc240 100644 --- a/mode_replace.py +++ b/mode_replace.py @@ -11,13 +11,14 @@ class Replace(mode2.Fundamental): self.actions = {} self.bindings = {} - default_actions = ((ReplaceAll(), ('a', '!',)), - (ReplaceOne(), ('y', 'SPACE',)), - (SkipReplace(), ('n', 'DELETE',)), - (CancelReplace(), ('q', 'RETURN', 'C-]', 'C-n', - 'C-p', 'C-a', 'C-e', 'C-f', - 'C-b'))) - + default_actions = ( + (ReplaceAll(), ('a', '!',)), + (ReplaceOne(), ('y', 'SPACE',)), + (SkipReplace(), ('n', 'DELETE',)), + (CancelReplace(), ('q', 'RETURN', 'C-]', 'C-n', 'C-p', 'C-a', 'C-e', + 'C-f', 'C-b')), + ) + # add the replace actions for pair in default_actions: (action, sequences) = pair @@ -31,51 +32,55 @@ class Replace(mode2.Fundamental): return "Replace" class ReplaceOne(method.Method): - def execute(self, window, **vargs): - m = window.buffer.method + def execute(self, w, **vargs): + m = w.buffer.method old_window = m.old_window _replace(m, old_window) - _find_next(window, True) - _finish(m, window, old_window) + _find_next(w, True) + _finish(m, w, old_window) class SkipReplace(method.Method): - def execute(self, window, **vargs): - m = window.buffer.method + def execute(self, w, **vargs): + m = w.buffer.method old_window = m.old_window - _find_next(window, True) - _finish(m, window, old_window) + _find_next(w, True) + _finish(m, w, old_window) class ReplaceAll(method.Method): - def execute(self, window, **vargs): - m = window.buffer.method + def execute(self, w, **vargs): + m = w.buffer.method old_window = m.old_window while m.p1 is not None: _replace(m, old_window) - _find_next(window, True) - _end(window) - window.application.set_error("Replace ended") + _find_next(w, True) + _end(w) + w.application.set_error("Replace ended") class CancelReplace(method.Method): - def execute(self, window, **vargs): - _end(window) - window.application.set_error("Replace cancelled") + def execute(self, w, **vargs): + _end(w) + w.application.set_error("Replace cancelled") -def _set_prompt(m, window): - i = m.old_window.buffer.get_point_offset(m.p1) - s = m.old_window.buffer.make_string() - count = s[i:].count(m.before) +def _set_prompt(m, w): + (x, y) = m.p1.xy() + count = 0 + while y < len(w.buffer.lines): + count += w.buffer.lines[y][x:].count(m.before) + y += 1 + x = 0 if count > 1: - window.application.mini_prompt = 'Replace %r with %r [ynaq] (%d occurances)?' % (m.before, m.after, count) + p = 'Replace %r with %r [ynaq] (%d occurances)?' % (m.before, m.after, count) else: - window.application.mini_prompt = 'Replace %r with %r [ynaq] (1 occurance)?' % (m.before, m.after) + p = 'Replace %r with %r [ynaq] (1 occurance)?' % (m.before, m.after) + w.application.mini_prompt = p def _replace(m, old_window): - old_window.buffer.delete_string(m.p1, m.p2) + old_window.buffer.delete(m.p1, m.p2) if m.after: old_window.buffer.insert_string(m.p1, m.after) -def _find_next(window, move=False): - m = window.buffer.method +def _find_next(w, move=False): + m = w.buffer.method old_window = m.old_window b = old_window.buffer s = m.before @@ -111,16 +116,15 @@ def _find_next(window, move=False): m.p1 = None m.p2 = None -def _finish(m, window, old_window): +def _finish(m, w, old_window): if m.p1 is None: - _end(window) - window.application.set_error("Replace ended") + _end(w) + w.application.set_error("Replace ended") else: _set_prompt(m, old_window) -def _end(window): - window.application.close_mini_buffer() - #window.application.highlighted_range = [] - window.application.clear_highlighted_ranges() - window.buffer.method.old_cursor = None - window.buffer.method.old_window = None +def _end(w): + w.application.close_mini_buffer() + w.application.clear_highlighted_ranges() + w.buffer.method.old_cursor = None + w.buffer.method.old_window = None diff --git a/window2.py b/window2.py index 1846a52..bcdca12 100644 --- a/window2.py +++ b/window2.py @@ -4,12 +4,11 @@ from point2 import Point WORD_LETTERS = list(string.letters + string.digits) -# note about the cursor: the cursor position will insert in front of -# the character it highlights. to this end, it needs to be able to -# highlight behind the last character on a line. thus, the x -# coordinate of the (logical) cursor can equal the length of lines[y], -# even though lines[y][x] throws an index error. both buffer and -# window need to be aware of this possibility for points. +# note about the cursor: the cursor position will insert in front of the +# character it highlights. to this end, it needs to be able to highlight behind +# the last character on a line. thus, the x coordinate of the (logical) cursor +# can equal the length of lines[y], even though lines[y][x] throws an index +# error. both buffer and window need to be aware of this possibility for points. class Window(object): def __init__(self, b, a, height=24, width=80, mode_name=None): @@ -85,9 +84,31 @@ class Window(object): if not self.point_is_visible(p): self.application.set_error(msg % {'x': p.x, 'y': p.y}) + # point left + def point_left(self, p): + if p.y == 0 and p.x == 0: + return None + elif p.x == 0: + return Point(len(self.buffer.lines[p.y - 1]), p.y - 1) + else: + return Point(p.x - 1, p.y) + + # point right + def point_right(self, p): + if p.y == len(self.buffer.lines)-1 and p.x == len(self.buffer.lines[-1]): + return None + elif p.x == len(self.buffer.lines[p.y]): + return Point(0, p.y + 1) + else: + return Point(p.x + 1, p.y) + # cursors def logical_cursor(self): - x = min(self.cursor.x, len(self.buffer.lines[self.cursor.y])) + if len(self.buffer.lines) > self.cursor.y: + l = len(self.buffer.lines[self.cursor.y]) + else: + l = 0 + x = min(self.cursor.x, l) return Point(x, self.cursor.y) # last visible point @@ -454,17 +475,20 @@ class Window(object): return self.application.pop_kill() # querying - def highlighted_char(self): + def cursor_char(self): self.point_char(self.logical_cursor()) def point_char(self, p): return self.xy_char(p.x, p.y) def xy_char(self, x, y): + #assert 0 <= y and y < len(self.buffer.lines) + #assert 0 <= x and x <= len(self.buffer.lines[y]) if x == len(self.buffer.lines[y]): return "\n" else: return self.buffer.lines[y][x] # undo/redo + # XYZ def undo(self): # TODO: put something here to move the cursor to the area of the undo self.buffer.undo()