570 lines
19 KiB
Python
570 lines
19 KiB
Python
import os.path, string
|
|
|
|
import buffer, point, regex
|
|
|
|
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.
|
|
|
|
class Window(object):
|
|
def __init__(self, b, a, height=24, width=80, slot='main', mode_name=None):
|
|
self.buffer = b
|
|
self.application = a
|
|
self.buffer.add_window(self, slot)
|
|
|
|
self.first = point.Point(0, 0, "logical")
|
|
self.last = point.Point(0, 0, "logical")
|
|
self.cursor = point.Point(0, 0, "logical")
|
|
self.mark = None
|
|
self.active_point = None
|
|
|
|
#self.physical_movement = False
|
|
|
|
self.height = height
|
|
self.width = width
|
|
|
|
self._logical_offsets = None
|
|
self._physical_lines = None
|
|
self._physical_lines_cont = None
|
|
|
|
self.input_line = ""
|
|
|
|
if mode_name is not None:
|
|
pass
|
|
elif hasattr(self.buffer, 'modename') and self.buffer.modename is not None:
|
|
mode_name = self.buffer.modename
|
|
elif self.buffer.name() == "*Minibuffer*":
|
|
mode_name = 'mini'
|
|
elif self.buffer.name() == "*Console*":
|
|
#mode_name = "console"
|
|
mode_name = "fundamental"
|
|
elif hasattr(self.buffer, 'path'):
|
|
path = self.buffer.path
|
|
basename = os.path.basename(path)
|
|
#ext = os.path.splitext(path)[1].lower()
|
|
ext = self._get_path_ext(path)
|
|
if path in self.application.mode_paths:
|
|
mode_name = self.application.mode_paths[path]
|
|
elif basename in self.application.mode_basenames:
|
|
mode_name = self.application.mode_basenames[basename]
|
|
elif ext in self.application.mode_extensions:
|
|
mode_name = self.application.mode_extensions[ext]
|
|
elif len(self.buffer.lines) > 0 and \
|
|
self.buffer.lines[0].startswith('#!'):
|
|
line = self.buffer.lines[0]
|
|
for word in self.application.mode_detection:
|
|
if word in line:
|
|
mode_name = self.application.mode_detection[word]
|
|
|
|
if mode_name is None:
|
|
mode_name = "fundamental"
|
|
|
|
m = self.application.modes[mode_name](self)
|
|
self.set_mode(m)
|
|
|
|
def _get_path_ext(self, path):
|
|
name = os.path.basename(path).lower()
|
|
tokens = name.split('.')
|
|
if len(tokens) > 2 and tokens[-1] in ('gz', 'in', 'zip'):
|
|
return '.%s.%s' % (tokens[-2], tokens[-1])
|
|
else:
|
|
return os.path.splitext(path)[1].lower()
|
|
|
|
def set_mode(self, m):
|
|
self.mode = m
|
|
self.redraw()
|
|
|
|
def get_cursor_offset(self):
|
|
cursor = self.logical_cursor()
|
|
return self.buffer.get_point_offset(cursor)
|
|
|
|
# the message is printed when the point is not visible, and the proper
|
|
# variable is set
|
|
def set_active_point(self, p, use_msg_when_hidden=True,
|
|
msg='marking on line %(y)d, character %(x)d'):
|
|
self.active_point = p
|
|
if not self.point_is_visible(p):
|
|
self.application.set_error(msg % {'x': p.x, 'y': p.y})
|
|
|
|
# cursors
|
|
#
|
|
# there are three:
|
|
# the actual cursor (not good for most things)
|
|
# the logical cursor (good for logical actions on buffer)
|
|
# the physical cursor (good for drawing)
|
|
def logical_cursor(self):
|
|
y = self.cursor.y
|
|
if self.cursor.x <= len(self.buffer.lines[y]):
|
|
return self.cursor
|
|
else:
|
|
return point.Point(len(self.buffer.lines[y]), y, "logical")
|
|
def logical_point(self, p):
|
|
self.get_physical_lines()
|
|
x = 0
|
|
y = 0
|
|
for i in range(0, p.y):
|
|
if self._physical_lines_cont[i]:
|
|
x += self.width
|
|
else:
|
|
x = 0
|
|
y += 1
|
|
x += p.x
|
|
return point.Point(x, y, "logical")
|
|
def physical_cursor(self):
|
|
p = self.logical_cursor()
|
|
#return self.physical_point(p)
|
|
self.get_physical_lines()
|
|
y = 0
|
|
for i in self._logical_offsets[0:p.y]:
|
|
y += i
|
|
y += p.x / self.width
|
|
x = p.x % self.width
|
|
# this allows the cursor to be in the right margin, rather than on the
|
|
# next line... i.e. not the behavior you want for actual text.
|
|
if p.x == len(self.buffer.lines[p.y]) and y > 0 and p.x > 0 and x == 0:
|
|
#if y > 0 and p.x > 0 and x == 0:
|
|
x = self.width
|
|
y -= 1
|
|
return point.Point(x, y, "physical")
|
|
def physical_point(self, p):
|
|
self.get_physical_lines()
|
|
y = 0
|
|
for i in self._logical_offsets[0:p.y]:
|
|
y += i
|
|
y += p.x / self.width
|
|
x = p.x % self.width
|
|
return point.Point(x, y, "physical")
|
|
|
|
# debug
|
|
def get_debug_repr(self):
|
|
return ""
|
|
|
|
def get_physical_lines(self):
|
|
if self._physical_lines is None:
|
|
self._physical_lines = []
|
|
self._physical_lines_cont = []
|
|
self._logical_offsets = []
|
|
for l in self.buffer.lines:
|
|
pl = []
|
|
while len(l) > self.width:
|
|
pl.append(l[:self.width])
|
|
l = l[self.width:]
|
|
pl.append(l)
|
|
self._logical_offsets.append(len(pl))
|
|
self._physical_lines.extend(pl)
|
|
for i in range(0, len(pl)-1):
|
|
self._physical_lines_cont.append(True)
|
|
self._physical_lines_cont.append(False)
|
|
return self._physical_lines
|
|
|
|
# redrawing
|
|
def set_size(self, width, height):
|
|
self.width = width
|
|
self.height = height
|
|
self.redraw()
|
|
self._invalidate_physical_lines()
|
|
self.mode.invalidate()
|
|
def _invalidate_physical_lines(self):
|
|
self._physical_lines = None
|
|
|
|
def _region_added(self, p, xdiff, ydiff, str=None):
|
|
cursor = self.logical_cursor()
|
|
self._invalidate_physical_lines()
|
|
if cursor.y > p.y:
|
|
self.cursor = cursor.offset(0, ydiff)
|
|
elif self.cursor >= p:
|
|
self.cursor = cursor.offset(xdiff, ydiff)
|
|
else:
|
|
pass
|
|
self.redraw() # added 2006-5-28
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
self.mode.region_added(p, xdiff, ydiff, str)
|
|
|
|
def _region_removed(self, p1, p2, str):
|
|
pdelta = p1 - p2
|
|
xdiff, ydiff = pdelta.x, pdelta.y
|
|
self._invalidate_physical_lines()
|
|
if self.cursor.y > p2.y:
|
|
self.cursor = self.cursor.offset(0, ydiff)
|
|
elif self.cursor > p2:
|
|
self.cursor = self.cursor.offset(xdiff, ydiff)
|
|
elif self.cursor >= p1:
|
|
self.cursor = p1.offset(0, 0)
|
|
else:
|
|
pass
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
self.mode.region_removed(p1, p2, str)
|
|
|
|
def visible_offset(self):
|
|
pfirst = self.physical_point(self.first)
|
|
return pfirst.y
|
|
def visible_cursor(self):
|
|
i = self.visible_offset()
|
|
return self.physical_cursor().offset(0, -i)
|
|
def visible_lines(self):
|
|
i = self.visible_offset()
|
|
lines = self.get_physical_lines()
|
|
return lines[i:i+self.height]
|
|
def continued_visible_line(self, i):
|
|
return self._physical_lines_cont[i + self.visible_offset()]
|
|
def redraw(self):
|
|
plines = self.get_physical_lines()
|
|
pfirst = self.physical_point(self.first)
|
|
py = min(pfirst.y + self.height - 1, len(plines) - 1)
|
|
px = min(self.width, len(plines[py]))
|
|
plast = point.Point(px, py, "physical")
|
|
self.last = self.logical_point(plast)
|
|
if self.last < self.first:
|
|
raise Exception, "BUGGJGJG:\n%s" % (self.dump())
|
|
self._validate_first_last()
|
|
def point_is_visible(self, p):
|
|
return self.first <= p and p <= self.last
|
|
def cursor_is_visible(self):
|
|
cursor = self.logical_cursor()
|
|
return self.point_is_visible(cursor)
|
|
def first_is_visible(self):
|
|
first_point = self.buffer.get_buffer_start()
|
|
return self.point_is_visible(first_point)
|
|
def last_is_visible(self):
|
|
last_point = self.buffer.get_buffer_end()
|
|
return self.point_is_visible(last_point)
|
|
|
|
def center_view(self):
|
|
pcursor = self.physical_cursor()
|
|
x = 0
|
|
if self.height == 1:
|
|
# we special case this to avoid rounding problems
|
|
y = max(0, pcursor.y)
|
|
else:
|
|
offset = self.height - (self.height / 2)
|
|
y = max(0, pcursor.y - offset)
|
|
pfirst = point.Point(x, y, "physical")
|
|
self.first = self.logical_point(pfirst)
|
|
self.redraw()
|
|
def relocate_cursor(self):
|
|
if not self.cursor_is_visible():
|
|
i = self.visible_offset()
|
|
pp = point.Point(0, i, "physical")
|
|
lp = self.logical_point(pp)
|
|
self.goto(lp)
|
|
|
|
# point validation
|
|
def _validate_cursor(self):
|
|
self.buffer._validate_point(self.logical_cursor())
|
|
def _validate_mark(self):
|
|
self.buffer._validate_point(self.mark)
|
|
def _validate_first_last(self):
|
|
assert self.first <= self.logical_cursor(), "one"
|
|
assert (self.first.x % self.width) == 0, "two: %d %% %d != 0 (%d)" % (self.first.x, self.width, self.first.x % self.width)
|
|
assert self.first <= self.last, "four"
|
|
|
|
# moving in buffer
|
|
def forward(self):
|
|
cursor = self.logical_cursor()
|
|
if cursor.x < len(self.buffer.lines[cursor.y]):
|
|
self.cursor.x = cursor.x + 1
|
|
elif cursor.y < len(self.buffer.lines) - 1:
|
|
self.cursor.y = cursor.y + 1
|
|
self.cursor.x = 0
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
def backward(self):
|
|
cursor = self.logical_cursor()
|
|
if cursor.x > 0:
|
|
self.cursor.x = cursor.x - 1
|
|
elif self.cursor.y > 0:
|
|
self.cursor.y = cursor.y - 1
|
|
self.cursor.x = len(self.buffer.lines[self.cursor.y])
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
def end_of_line(self):
|
|
self.cursor.x = len(self.buffer.lines[self.cursor.y])
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
def start_of_line(self):
|
|
self.cursor.x = 0
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
def previous_line(self):
|
|
if self.cursor.y > 0:
|
|
self.cursor.y -= 1
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
def next_line(self):
|
|
if self.cursor.y < len(self.buffer.lines) - 1:
|
|
self.cursor.y += 1
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
|
|
def pshift(self, p, i):
|
|
y = max(0, p.y + i)
|
|
y = min(y, len(self._physical_lines) - 1)
|
|
x = min(len(self._physical_lines[y]), p.x)
|
|
return self.logical_point(point.Point(x, y, "physical"))
|
|
|
|
# word handling
|
|
def find_left_word(self, p=None):
|
|
if p is None:
|
|
p = self.logical_cursor().offset(0, 0)
|
|
start = self.buffer.get_buffer_start()
|
|
if p == start:
|
|
return
|
|
elif p.x == 0:
|
|
p.y -= 1
|
|
p.x = len(self.buffer.lines[p.y])
|
|
else:
|
|
p.x -= 1
|
|
while p >= start and self.point_char(p) not in WORD_LETTERS:
|
|
if p.x == 0:
|
|
p.y -= 1
|
|
p.x = len(self.buffer.lines[p.y])
|
|
else:
|
|
p.x -= 1
|
|
found_word = False
|
|
while p >= start and self.point_char(p) in WORD_LETTERS:
|
|
found_word = True
|
|
if p.x == 0:
|
|
p.y -= 1
|
|
p.x = len(self.buffer.lines[p.y])
|
|
else:
|
|
p.x -= 1
|
|
if not found_word:
|
|
pass
|
|
elif p.x == len(self.buffer.lines[p.y]):
|
|
p.x = 0
|
|
p.y += 1
|
|
else:
|
|
p.x += 1
|
|
return p
|
|
def find_right_word(self, p=None):
|
|
if p is None:
|
|
p = self.logical_cursor().offset(0, 0)
|
|
end = self.buffer.get_buffer_end()
|
|
while p < end and self.point_char(p) not in WORD_LETTERS:
|
|
if p.x == len(self.buffer.lines[p.y]):
|
|
p.x = 0
|
|
p.y += 1
|
|
else:
|
|
p.x += 1
|
|
while p < end and self.point_char(p) in WORD_LETTERS:
|
|
if p.x == len(self.buffer.lines[p.y]):
|
|
p.x = 0
|
|
p.y += 1
|
|
else:
|
|
p.x += 1
|
|
return p
|
|
def left_word(self):
|
|
p = self.find_left_word()
|
|
if p is not None:
|
|
self.goto(p)
|
|
def right_word(self):
|
|
p = self.find_right_word()
|
|
if p is not None:
|
|
self.goto(p)
|
|
|
|
# page up/down
|
|
def page_up(self):
|
|
first_point = self.buffer.get_buffer_start()
|
|
if self.point_is_visible(first_point):
|
|
self.goto_beginning()
|
|
return
|
|
self.cursor = self.pshift(self.physical_cursor(), 3 - self.height)
|
|
if self.first > first_point:
|
|
self.first = self.pshift(self.physical_point(self.first), 3 - self.height)
|
|
self.redraw()
|
|
def page_down(self):
|
|
last_point = self.buffer.get_buffer_end()
|
|
if self.point_is_visible(last_point):
|
|
self.goto_end()
|
|
return
|
|
self.cursor = self.pshift(self.physical_cursor(), self.height - 3)
|
|
if self.last < last_point:
|
|
self.first = self.pshift(self.physical_point(self.first), self.height - 3)
|
|
self.redraw()
|
|
|
|
# jumping in buffer
|
|
def goto(self, p):
|
|
self.buffer._validate_point(p)
|
|
self.cursor.x = p.x
|
|
self.cursor.y = p.y
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
def goto_line(self, y):
|
|
if y < 0:
|
|
y = len(self.buffer.lines) + y + 1
|
|
self.buffer._validate_y(y)
|
|
self.cursor.y = y
|
|
self.cursor.x = 0
|
|
if not self.cursor_is_visible():
|
|
self.center_view()
|
|
def forward_lines(self, n):
|
|
assert n > 0, "illegal number of lines: %d" % n
|
|
m = 0
|
|
p = self.logical_cursor().copy()
|
|
while m < n and p.y < len(self.buffer.lines):
|
|
p.y += 1
|
|
m += 1
|
|
self.goto(p)
|
|
def forward_chars(self, n):
|
|
m = 0
|
|
p = self.logical_cursor().copy()
|
|
while p < self.last and m < n:
|
|
if p.x == len(self.buffer.lines[p.y]):
|
|
p.y += 1
|
|
p.x = 0
|
|
m += 1
|
|
else:
|
|
p.x += 1
|
|
m += 1
|
|
self.goto(p)
|
|
def goto_char(self, n):
|
|
self.goto(point.Point(0, 0))
|
|
self.forward_chars(n)
|
|
def goto_beginning(self):
|
|
self.cursor = self.buffer.get_buffer_start()
|
|
self.first = self.buffer.get_buffer_start()
|
|
self.redraw()
|
|
def goto_end(self):
|
|
self.cursor = self.buffer.get_buffer_end()
|
|
if not self.cursor_is_visible():
|
|
pcursor = self.physical_cursor()
|
|
pfirst = pcursor.offset(0, 3 - self.height)
|
|
pfirst.x = 0
|
|
self.first = self.logical_point(pfirst)
|
|
self.redraw()
|
|
|
|
# mark manipulation
|
|
def set_mark_point(self, p):
|
|
self.mark = p.offset(0, 0)
|
|
def set_mark(self):
|
|
cursor = self.logical_cursor()
|
|
self.set_mark_point(cursor)
|
|
self.application.set_error("Mark set")
|
|
def goto_mark(self):
|
|
self.goto(self.mark)
|
|
def switch_mark(self):
|
|
if self.mark:
|
|
p = self.mark
|
|
cursor = self.logical_cursor()
|
|
self.set_mark_point(cursor)
|
|
self.goto(p)
|
|
|
|
# deletion
|
|
def left_delete(self):
|
|
cursor = self.logical_cursor()
|
|
if cursor.x > 0:
|
|
self.buffer.delete_character(cursor.offset(-1, 0, "logical"))
|
|
elif cursor.y > 0:
|
|
self.buffer.delete_character(point.Point(len(self.buffer.lines[cursor.y-1]),
|
|
cursor.y - 1,
|
|
"logical"))
|
|
else:
|
|
pass
|
|
def right_delete(self):
|
|
cursor = self.logical_cursor()
|
|
if cursor < self.last:
|
|
self.buffer.delete_character(cursor)
|
|
else:
|
|
pass
|
|
|
|
# killing
|
|
def kill_line(self):
|
|
return self.copy_line(kill=True)
|
|
def kill_region(self):
|
|
return self.copy_region(kill=True)
|
|
def kill_left_word(self):
|
|
p1 = self.find_left_word()
|
|
p2 = self.logical_cursor()
|
|
if p1 == p2:
|
|
return
|
|
return self.kill(p1, p2)
|
|
def kill_right_word(self):
|
|
p1 = self.logical_cursor()
|
|
p2 = self.find_right_word()
|
|
if p1 == p2:
|
|
return
|
|
return self.kill(p1, p2)
|
|
def copy_line(self, kill=False):
|
|
cursor = self.logical_cursor()
|
|
if (cursor.x < len(self.buffer.lines[cursor.y]) and
|
|
not regex.whitespace.match(self.buffer.lines[cursor.y][cursor.x:])):
|
|
limit = point.Point(len(self.buffer.lines[cursor.y]), cursor.y, "logical")
|
|
elif cursor.y < len(self.buffer.lines) - 1:
|
|
limit = point.Point(0, cursor.y + 1, "logical")
|
|
else:
|
|
return
|
|
if kill:
|
|
return self.kill(cursor, limit)
|
|
else:
|
|
return self.copy(cursor, limit)
|
|
def copy_region(self, kill=False):
|
|
cursor = self.logical_cursor()
|
|
if cursor < self.mark:
|
|
p1 = cursor
|
|
p2 = self.mark
|
|
elif self.mark < cursor:
|
|
p1 = self.mark
|
|
p2 = cursor
|
|
else:
|
|
self.input_line = "Empty kill region"
|
|
return
|
|
if kill:
|
|
return self.kill(p1, p2)
|
|
else:
|
|
return self.copy(p1, p2)
|
|
def kill(self, p1, p2):
|
|
killed = self.buffer.get_substring(p1, p2)
|
|
self.buffer.delete_string(p1, p2)
|
|
self.application.push_kill(killed)
|
|
return killed
|
|
def copy(self, p1, p2):
|
|
copied = self.buffer.get_substring(p1, p2)
|
|
self.application.push_kill(copied)
|
|
return copied
|
|
|
|
# insertion
|
|
def insert_string(self, s):
|
|
cursor = self.logical_cursor()
|
|
self.insert(cursor, s)
|
|
def insert(self, p, s):
|
|
c = s.count('\n')
|
|
if c > 0:
|
|
y = p.y + c
|
|
x = len(s) - (c + 1) - 1
|
|
else:
|
|
y = p.y
|
|
x = p.x + len(s)
|
|
self.buffer.insert_string(p, s)
|
|
def yank(self):
|
|
s = self.application.get_kill()
|
|
self.insert_string(s)
|
|
def pop_kill(self):
|
|
return self.application.pop_kill()
|
|
|
|
# querying
|
|
def highlighted_char(self):
|
|
cursor = self.logical_cursor()
|
|
self.point_char(cursor)
|
|
def point_char(self, p):
|
|
if p.x == len(self.buffer.lines[p.y]):
|
|
return "\n"
|
|
else:
|
|
return self.buffer.lines[p.y][p.x]
|
|
|
|
|
|
# region finding (p is a physical point)
|
|
def get_region(self, p):
|
|
regions = self.mode.get_regions()
|
|
assert len(regions[p.y]) > 0, "no regions found; strange"
|
|
for r in regions[p.y]:
|
|
if r.start <= p.x and r.end >= p.x + 1:
|
|
return r
|
|
return None
|