| author |
Steve Losh <steve@stevelosh.com> |
| date |
Tue, 14 Jan 2020 19:44:43 -0500 |
| parents |
136a9256bec2 |
| children |
(none) |
from __future__ import with_statement
import vim
from .util import buffers, keys, windows
from .settings import boolsetting, setting
current_mode = None
class Mode(object):
def __init__(self):
return super(Mode, self).__init__()
def diff(self, diffmode):
with buffers.remain():
with windows.remain():
getattr(self, '_diff_%d' % diffmode)()
# Reset the scrollbind to whatever it was before we diffed.
if not diffmode:
self.scrollbind(self._current_scrollbind)
def key_diff(self, diffmode=None):
next_diff_mode = self._current_diff_mode + 1
if next_diff_mode >= self._number_of_diff_modes:
next_diff_mode = 0
self.diff(next_diff_mode)
def diffoff(self):
with windows.remain():
for winnr in range(2, 2 + self._number_of_windows):
windows.focus(winnr)
curbuffer = buffers.current
for buffer in buffers.all:
buffer.open()
vim.command('diffoff')
if setting('wrap'):
vim.command('setlocal ' + setting('wrap'))
curbuffer.open()
def key_diffoff(self):
self.diff(0)
def scrollbind(self, enabled):
if self._current_diff_mode:
return
with windows.remain():
self._current_scrollbind = enabled
for winnr in range(2, 2 + self._number_of_windows):
windows.focus(winnr)
if enabled:
vim.command('set scrollbind')
else:
vim.command('set noscrollbind')
if enabled:
vim.command('syncbind')
def key_scrollbind(self):
self.scrollbind(not self._current_scrollbind)
def layout(self, layoutnr):
getattr(self, '_layout_%d' % layoutnr)()
self.diff(self._current_diff_mode)
self.redraw_hud()
def key_layout(self, diffmode=None):
next_layout = self._current_layout + 1
if next_layout >= self._number_of_layouts:
next_layout = 0
self.layout(next_layout)
def key_original(self):
pass
def key_one(self):
pass
def key_two(self):
pass
def key_result(self):
pass
def key_use(self):
pass
def activate(self):
self.layout(self._current_layout)
self.diff(self._current_diff_mode)
self.scrollbind(self._current_scrollbind)
def deactivate(self):
pass
def key_next(self):
self.goto_result()
vim.command(r'exe "silent! normal! /\\v^\\=\\=\\=\\=\\=\\=\\=*$\<cr>"')
def key_prev(self):
self.goto_result()
vim.command(r'exe "silent! normal! ?\\v^\\=\\=\\=\\=\\=\\=\\=*$\<cr>"')
def open_hud(self, winnr):
windows.split()
windows.focus(winnr)
buffers.hud.open()
vim.command('wincmd K')
self.redraw_hud()
def hud_lines(self):
def pad(lines):
l = max([len(line) for line in lines])
return [line.ljust(l) for line in lines]
sep = ' | '
modes = pad([
r'Splice Modes',
r'x[g]rid y[c]ompare'.replace('x', self._id == 'grid' and '*' or ' ')
.replace('y', self._id == 'comp' and '*' or ' '),
r'x[l]oupe y[p]ath'.replace('x', self._id == 'loup' and '*' or ' ')
.replace('y', self._id == 'path' and '*' or ' '),
])
diagram = pad(self.hud_diagram())
commands = pad([
r'Splice Commands',
r'd: cycle diffs n: next conflict space: cycle layouts u: use hunk o: original 1: one q: save and quit',
r'D: diffs off N: prev conflict s: toggle scrollbind r: result 2: two CC: exit with error',
])
lines = []
for line in modes:
lines.append(line + sep)
for i, line in enumerate(diagram):
lines[i] += line + sep
for i, line in enumerate(commands):
lines[i] += line + sep
for i, line in enumerate(lines):
lines[i] = line.rstrip()
return lines
def redraw_hud(self):
with windows.remain():
windows.focus(1)
vim.command('setlocal modifiable')
buffers.hud.set_lines(self.hud_lines())
vim.command('setlocal nomodifiable')
vim.command('set winfixheight')
vim.command('resize ' + setting('hud_size', '3'))
vim.command('wincmd =')
class GridMode(Mode):
"""
Layout 0 Layout 1 Layout 2
+-------------------+ +--------------------------+ +---------------+
| Original | | One | Result | Two | | One |
|2 | | | | | |2 |
+-------------------+ | | | | +---------------+
| One | Two | | | | | | Result |
|3 |4 | | | | | |3 |
+-------------------+ | | | | +---------------+
| Result | | | | | | Two |
|5 | |2 |3 |4 | |4 |
+-------------------+ +--------------------------+ +---------------+
"""
def __init__(self):
self._id = 'grid'
self._current_layout = int(setting('initial_layout_grid', 0))
self._current_diff_mode = int(setting('initial_diff_grid', 0))
self._current_scrollbind = boolsetting('initial_scrollbind_grid')
self._number_of_diff_modes = 2
self._number_of_layouts = 3
return super(GridMode, self).__init__()
def _layout_0(self):
self._number_of_windows = 4
self._current_layout = 0
# Open the layout
windows.close_all()
windows.split()
windows.split()
windows.focus(2)
windows.vsplit()
# Put the buffers in the appropriate windows
windows.focus(1)
buffers.original.open()
windows.focus(2)
buffers.one.open()
windows.focus(3)
buffers.two.open()
windows.focus(4)
buffers.result.open()
self.open_hud(5)
windows.focus(5)
def _layout_1(self):
self._number_of_windows = 3
self._current_layout = 1
# Open the layout
windows.close_all()
windows.vsplit()
windows.vsplit()
# Put the buffers in the appropriate windows
windows.focus(1)
buffers.one.open()
windows.focus(2)
buffers.result.open()
windows.focus(3)
buffers.two.open()
self.open_hud(4)
windows.focus(3)
def _layout_2(self):
self._number_of_windows = 4
self._current_layout = 2
# Open the layout
windows.close_all()
windows.split()
windows.split()
# Put the buffers in the appropriate windows
windows.focus(1)
buffers.one.open()
windows.focus(2)
buffers.result.open()
windows.focus(3)
buffers.two.open()
self.open_hud(4)
windows.focus(3)
def _diff_0(self):
self.diffoff()
self._current_diff_mode = 0
def _diff_1(self):
self.diffoff()
self._current_diff_mode = 1
for i in range(2, self._number_of_windows + 2):
windows.focus(i)
vim.command('diffthis')
def key_original(self):
if self._current_layout == 0:
windows.focus(2)
elif self._current_layout == 1:
return
elif self._current_layout == 2:
return
def key_one(self):
if self._current_layout == 0:
windows.focus(3)
elif self._current_layout == 1:
windows.focus(2)
elif self._current_layout == 2:
windows.focus(2)
def key_two(self):
if self._current_layout == 0:
windows.focus(4)
elif self._current_layout == 1:
windows.focus(4)
elif self._current_layout == 2:
windows.focus(4)
def key_result(self):
if self._current_layout == 0:
windows.focus(5)
elif self._current_layout == 1:
windows.focus(3)
elif self._current_layout == 2:
windows.focus(3)
def _key_use_0(self, target):
targetwin = 3 if target == 1 else 4
with windows.remain():
self.diffoff()
windows.focus(5)
vim.command('diffthis')
windows.focus(targetwin)
vim.command('diffthis')
def _key_use_12(self, target):
targetwin = 2 if target == 1 else 4
with windows.remain():
self.diffoff()
windows.focus(3)
vim.command('diffthis')
windows.focus(targetwin)
vim.command('diffthis')
def key_use1(self):
current_diff = self._current_diff_mode
if self._current_layout == 0:
self._key_use_0(1)
elif self._current_layout == 1:
self._key_use_12(1)
elif self._current_layout == 2:
self._key_use_12(1)
if buffers.current == buffers.result:
vim.command('diffget')
elif buffers.current in (buffers.one, buffers.two):
vim.command('diffput')
self.diff(current_diff)
def key_use2(self):
current_diff = self._current_diff_mode
if self._current_layout == 0:
self._key_use_0(2)
elif self._current_layout == 1:
self._key_use_12(2)
elif self._current_layout == 2:
self._key_use_12(2)
if buffers.current == buffers.result:
vim.command('diffget')
elif buffers.current in (buffers.one, buffers.two):
vim.command('diffput')
self.diff(current_diff)
def goto_result(self):
if self._current_layout == 0:
windows.focus(5)
elif self._current_layout == 1:
windows.focus(3)
elif self._current_layout == 2:
windows.focus(3)
def activate(self):
keys.unbind('u')
keys.bind('u1', ':SpliceUse1<cr>')
keys.bind('u2', ':SpliceUse2<cr>')
return super(GridMode, self).activate()
def deactivate(self):
keys.unbind('u1')
keys.unbind('u2')
keys.bind('u', ':SpliceUse<cr>')
return super(GridMode, self).deactivate()
def hud_diagram(self):
if self._current_layout == 0:
return [
r' Original',
r'Layout -> One Two',
r' Result',
]
elif self._current_layout == 1:
return [
r'',
r'Layout -> One Result Two',
r'',
]
elif self._current_layout == 2:
return [
r' One',
r'Layout -> Result',
r' Two',
]
class LoupeMode(Mode):
def __init__(self):
self._id = 'loup'
self._current_layout = int(setting('initial_layout_loupe', 0))
self._current_diff_mode = int(setting('initial_diff_loupe', 0))
self._current_scrollbind = boolsetting('initial_scrollbind_loupe')
self._number_of_diff_modes = 1
self._number_of_layouts = 1
self._current_buffer = buffers.result
return super(LoupeMode, self).__init__()
def _diff_0(self):
self.diffoff()
self._current_diff_mode = 0
def _layout_0(self):
self._number_of_windows = 1
self._current_layout = 0
# Open the layout
windows.close_all()
# Put the buffers in the appropriate windows
windows.focus(1)
self._current_buffer.open()
self.open_hud(2)
windows.focus(2)
def key_original(self):
windows.focus(2)
buffers.original.open()
self._current_buffer = buffers.original
self.redraw_hud()
def key_one(self):
windows.focus(2)
buffers.one.open()
self._current_buffer = buffers.one
self.redraw_hud()
def key_two(self):
windows.focus(2)
buffers.two.open()
self._current_buffer = buffers.two
self.redraw_hud()
def key_result(self):
windows.focus(2)
buffers.result.open()
self._current_buffer = buffers.result
self.redraw_hud()
def key_use(self):
pass
def goto_result(self):
self.key_result()
def hud_diagram(self):
buf = buffers.labels[self._current_buffer.name]
if self._current_layout == 0:
return [
r'',
r'Layout -> %s ' % (buf,),
r'',
]
class CompareMode(Mode):
def __init__(self):
self._id = 'comp'
self._current_layout = int(setting('initial_layout_compare', 0))
self._current_diff_mode = int(setting('initial_diff_compare', 0))
self._current_scrollbind = boolsetting('initial_scrollbind_compare')
self._number_of_diff_modes = 2
self._number_of_layouts = 2
self._current_buffer_first = buffers.original
self._current_buffer_second = buffers.result
return super(CompareMode, self).__init__()
def _diff_0(self):
self.diffoff()
self._current_diff_mode = 0
def _diff_1(self):
self.diffoff()
self._current_diff_mode = 1
windows.focus(2)
vim.command('diffthis')
windows.focus(3)
vim.command('diffthis')
def _layout_0(self):
self._number_of_windows = 2
self._current_layout = 0
# Open the layout
windows.close_all()
windows.vsplit()
# Put the buffers in the appropriate windows
windows.focus(1)
self._current_buffer_first.open()
windows.focus(2)
self._current_buffer_second.open()
self.open_hud(3)
windows.focus(3)
def _layout_1(self):
self._number_of_windows = 2
self._current_layout = 1
# Open the layout
windows.close_all()
windows.split()
# Put the buffers in the appropriate windows
windows.focus(1)
self._current_buffer_first.open()
windows.focus(2)
self._current_buffer_second.open()
self.open_hud(3)
windows.focus(3)
def key_original(self):
windows.focus(2)
buffers.original.open()
self._current_buffer_first = buffers.original
self.diff(self._current_diff_mode)
self.redraw_hud()
def key_one(self):
def open_one(winnr):
buffers.one.open(winnr)
if winnr == 2:
self._current_buffer_first = buffers.one
else:
self._current_buffer_second = buffers.one
self.diff(self._current_diff_mode)
self.redraw_hud()
curwindow = windows.currentnr()
if curwindow == 1:
curwindow = 2
# If file one is showing, go to it.
windows.focus(2)
if buffers.current == buffers.one:
return
windows.focus(3)
if buffers.current == buffers.one:
return
# If both the original and result are showing, open file one in the
# current window.
windows.focus(2)
if buffers.current == buffers.original:
windows.focus(3)
if buffers.current == buffers.result:
open_one(curwindow)
return
# If file two is in window 1, then we open file one in window 1.
windows.focus(2)
if buffers.current == buffers.two:
open_one(2)
return
# Otherwise, open file one in the current window.
open_one(curwindow)
def key_two(self):
def open_two(winnr):
buffers.two.open(winnr)
if winnr == 2:
self._current_buffer_first = buffers.two
else:
self._current_buffer_second = buffers.two
self.diff(self._current_diff_mode)
self.redraw_hud()
curwindow = windows.currentnr()
if curwindow == 1:
curwindow = 2
# If file two is showing, go to it.
windows.focus(2)
if buffers.current == buffers.two:
return
windows.focus(3)
if buffers.current == buffers.two:
return
# If both the original and result are showing, open file two in the
# current window.
windows.focus(2)
if buffers.current == buffers.original:
windows.focus(3)
if buffers.current == buffers.result:
open_two(curwindow)
return
# If file one and the result are showing, then we open file two in the
# current window.
windows.focus(2)
if buffers.current == buffers.one:
windows.focus(3)
if buffers.current == buffers.result:
open_two(curwindow)
return
# If file one is in window 2, then we open file two in window 2.
windows.focus(3)
if buffers.current == buffers.two:
open_two(3)
return
# Otherwise, open file two in window 2.
open_two(3)
def key_result(self):
windows.focus(3)
buffers.result.open()
self._current_buffer_second = buffers.result
self.diff(self._current_diff_mode)
self.redraw_hud()
def key_use(self):
active = (self._current_buffer_first, self._current_buffer_second)
if buffers.result not in active:
return
if buffers.one not in active and buffers.two not in active:
return
current_diff = self._current_diff_mode
with windows.remain():
self._diff_1() # diff the windows
if buffers.current == buffers.result:
vim.command('diffget')
elif buffers.current in (buffers.one, buffers.two):
vim.command('diffput')
self.diff(current_diff)
def goto_result(self):
self.key_result()
def hud_diagram(self):
first = buffers.labels[self._current_buffer_first.name]
second = buffers.labels[self._current_buffer_second.name]
if self._current_layout == 0:
return [
r'',
r'Layout -> %s %s' % (first, second),
r'',
]
elif self._current_layout == 1:
return [
r'',
r'Layout -> %s' % first,
r' %s' % second,
]
class PathMode(Mode):
def __init__(self):
self._id = 'path'
self._current_layout = int(setting('initial_layout_path', 0))
self._current_diff_mode = int(setting('initial_diff_path', 0))
self._current_scrollbind = boolsetting('initial_scrollbind_path')
self._number_of_diff_modes = 5
self._number_of_layouts = 2
self._current_mid_buffer = buffers.one
return super(PathMode, self).__init__()
def _diff_0(self):
self.diffoff()
self._current_diff_mode = 0
def _diff_1(self):
self.diffoff()
self._current_diff_mode = 1
windows.focus(2)
vim.command('diffthis')
windows.focus(4)
vim.command('diffthis')
def _diff_2(self):
self.diffoff()
self._current_diff_mode = 2
windows.focus(2)
vim.command('diffthis')
windows.focus(3)
vim.command('diffthis')
def _diff_3(self):
self.diffoff()
self._current_diff_mode = 3
windows.focus(3)
vim.command('diffthis')
windows.focus(4)
vim.command('diffthis')
def _diff_4(self):
self.diffoff()
self._current_diff_mode = 4
windows.focus(2)
vim.command('diffthis')
windows.focus(3)
vim.command('diffthis')
windows.focus(4)
vim.command('diffthis')
def _layout_0(self):
self._number_of_windows = 3
self._current_layout = 0
# Open the layout
windows.close_all()
windows.vsplit()
windows.vsplit()
# Put the buffers in the appropriate windows
windows.focus(1)
buffers.original.open()
windows.focus(2)
self._current_mid_buffer.open()
windows.focus(3)
buffers.result.open()
self.open_hud(4)
windows.focus(4)
def _layout_1(self):
self._number_of_windows = 3
self._current_layout = 1
# Open the layout
windows.close_all()
windows.split()
windows.split()
# Put the buffers in the appropriate windows
windows.focus(1)
buffers.original.open()
windows.focus(2)
self._current_mid_buffer.open()
windows.focus(3)
buffers.result.open()
self.open_hud(4)
windows.focus(4)
def key_original(self):
windows.focus(2)
def key_one(self):
windows.focus(3)
buffers.one.open()
self._current_mid_buffer = buffers.one
self.diff(self._current_diff_mode)
windows.focus(3)
self.redraw_hud()
def key_two(self):
windows.focus(3)
buffers.two.open()
self._current_mid_buffer = buffers.two
self.diff(self._current_diff_mode)
windows.focus(3)
self.redraw_hud()
def key_result(self):
windows.focus(4)
def key_use(self):
current_diff = self._current_diff_mode
with windows.remain():
self._diff_3() # diff the middle and result windows
if buffers.current == buffers.result:
vim.command('diffget')
elif buffers.current in (buffers.one, buffers.two):
vim.command('diffput')
self.diff(current_diff)
def goto_result(self):
windows.focus(4)
def hud_diagram(self):
if self._current_mid_buffer == buffers.one:
buf = 'One'
else:
buf = 'Two'
if self._current_layout == 0:
return [
r'',
r'Layout -> Original %s Result' % buf,
r'',
]
elif self._current_layout == 1:
return [
r' Original',
r'Layout -> %s' % buf,
r' Result',
]
grid = GridMode()
loupe = LoupeMode()
compare = CompareMode()
path = PathMode()
def key_grid():
global current_mode
current_mode.deactivate()
current_mode = grid
grid.activate()
def key_loupe():
global current_mode
current_mode.deactivate()
current_mode = loupe
loupe.activate()
def key_compare():
global current_mode
current_mode.deactivate()
current_mode = compare
compare.activate()
def key_path():
global current_mode
current_mode.deactivate()
current_mode = path
path.activate()