# coding=UTF-8

# Copyright (C) 2002-2006 Stephen Kennedy <stevek@gnome.org>

# Copyright (C) 2009-2013 Kai Willadsen <kai.willadsen@gmail.com>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 2 of the License, or (at

# your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

import copy

import functools

import io

import os

import time

from multiprocessing import Pool

from multiprocessing.pool import ThreadPool

from gi.repository import GLib

from gi.repository import GObject

from gi.repository import Gio

from gi.repository import Gdk

from gi.repository import Gtk

from meld.conf import _

from . import diffutil

from . import matchers

from . import meldbuffer

from . import melddoc

from . import merge

from . import misc

from . import patchdialog

from . import recent

from . import undo

from .ui import findbar

from .ui import gnomeglade

from meld.const import MODE_REPLACE, MODE_DELETE, MODE_INSERT, NEWLINES

from meld.settings import bind_settings, meldsettings, settings

from .util.compat import text_type

from meld.sourceview import LanguageManager

class CachedSequenceMatcher(object):

"""Simple class for caching diff results, with LRU-based eviction

Results from the SequenceMatcher are cached and timestamped, and

subsequently evicted based on least-recent generation/usage. The LRU-based

eviction is overly simplistic, but is okay for our usage pattern.

"""

process_pool = None

def __init__(self):

if self.process_pool is None:

if os.name == "nt":

CachedSequenceMatcher.process_pool = ThreadPool(None)

else:

CachedSequenceMatcher.process_pool = Pool(

None, matchers.init_worker, maxtasksperchild=1)

self.cache = {}

def match(self, text1, textn, cb):

try:

self.cache[(text1, textn)][1] = time.time()

opcodes = self.cache[(text1, textn)][0]

GLib.idle_add(lambda: cb(opcodes))

except KeyError:

def inline_cb(opcodes):

self.cache[(text1, textn)] = [opcodes, time.time()]

GLib.idle_add(lambda: cb(opcodes))

self.process_pool.apply_async(matchers.matcher_worker,

(text1, textn),

callback=inline_cb)

def clean(self, size_hint):

"""Clean the cache if necessary

@param size_hint: the recommended minimum number of cache entries

"""

if len(self.cache) < size_hint * 3:

return

items = self.cache.items()

items.sort(key=lambda it: it[1][1])

for item in items[:-size_hint * 2]:

del self.cache[item[0]]

MASK_SHIFT, MASK_CTRL = 1, 2

PANE_LEFT, PANE_RIGHT = -1, +1

class CursorDetails(object):

__slots__ = ("pane", "pos", "line", "offset", "chunk", "prev", "next",

"prev_conflict", "next_conflict")

def __init__(self):

for var in self.__slots__:

setattr(self, var, None)

class TaskEntry(object):

__slots__ = ("filename", "file", "buf", "codec", "pane", "was_cr")

def __init__(self, *args):

for var, val in zip(self.__slots__, args):

setattr(self, var, val)

class TextviewLineAnimation(object):

__slots__ = ("start_mark", "end_mark", "start_rgba", "end_rgba",

"start_time", "duration")

def __init__(self, mark0, mark1, rgba0, rgba1, duration):

self.start_mark = mark0

self.end_mark = mark1

self.start_rgba = rgba0

self.end_rgba = rgba1

self.start_time = GLib.get_monotonic_time()

self.duration = duration

class FileDiff(melddoc.MeldDoc, gnomeglade.Component):

"""Two or three way comparison of text files"""

__gtype_name__ = "FileDiff"

__gsettings_bindings__ = (

('highlight-current-line', 'highlight-current-line'),

('ignore-blank-lines', 'ignore-blank-lines'),

)

highlight_current_line = GObject.property(type=bool, default=False)

ignore_blank_lines = GObject.property(

type=bool,

nick="Ignore blank lines",

blurb="Whether to ignore blank lines when comparing file contents",

default=False,

)

differ = diffutil.Differ

keylookup = {

Gdk.KEY_Shift_L: MASK_SHIFT,

Gdk.KEY_Shift_R: MASK_SHIFT,

Gdk.KEY_Control_L: MASK_CTRL,

Gdk.KEY_Control_R: MASK_CTRL,

}

# Identifiers for MsgArea messages

(MSG_SAME, MSG_SLOW_HIGHLIGHT, MSG_SYNCPOINTS) = list(range(3))

text_windows = {

Gtk.TextWindowType.TEXT,

Gtk.TextWindowType.LEFT,

Gtk.TextWindowType.RIGHT,

}

__gsignals__ = {

'next-conflict-changed': (GObject.SignalFlags.RUN_FIRST, None, (bool, bool)),

'action-mode-changed': (GObject.SignalFlags.RUN_FIRST, None, (int,)),

}

def __init__(self, num_panes):

"""Start up an filediff with num_panes empty contents.

"""

melddoc.MeldDoc.__init__(self)

gnomeglade.Component.__init__(

self, "filediff.ui", "filediff", ["FilediffActions"])

bind_settings(self)

widget_lists = [

"diffmap", "file_save_button", "file_toolbar", "fileentry",

"linkmap", "msgarea_mgr", "readonlytoggle",

"scrolledwindow", "selector_hbox", "textview", "vbox",

"dummy_toolbar_linkmap", "filelabel_toolitem", "filelabel",

"fileentry_toolitem", "dummy_toolbar_diffmap"

]

self.map_widgets_into_lists(widget_lists)

# This SizeGroup isn't actually necessary for FileDiff; it's for

# handling non-homogenous selectors in FileComp. It's also fragile.

column_sizes = Gtk.SizeGroup(mode=Gtk.SizeGroupMode.HORIZONTAL)

column_sizes.set_ignore_hidden(True)

for widget in self.selector_hbox:

column_sizes.add_widget(widget)

self.warned_bad_comparison = False

for v in self.textview:

buf = meldbuffer.MeldBuffer()

buf.connect('begin_user_action',

self.on_textbuffer_begin_user_action)

buf.connect('end_user_action', self.on_textbuffer_end_user_action)

v.set_buffer(buf)

buf.data.connect('file-changed', self.notify_file_changed)

v.late_bind()

self._keymask = 0

self.load_font()

self.meta = {}

self.deleted_lines_pending = -1

self.textview_overwrite = 0

self.focus_pane = None

self.textview_overwrite_handlers = [ t.connect("toggle-overwrite", self.on_textview_toggle_overwrite) for t in self.textview ]

self.textbuffer = [v.get_buffer() for v in self.textview]

self.buffer_texts = [meldbuffer.BufferLines(b) for b in self.textbuffer]

self.undosequence = undo.UndoSequence()

self.text_filters = []

self.create_text_filters()

self.settings_handlers = [

meldsettings.connect("text-filters-changed",

self.on_text_filters_changed)

]

self.buffer_filtered = [meldbuffer.BufferLines(b, self._filter_text)

for b in self.textbuffer]

for (i, w) in enumerate(self.scrolledwindow):

w.get_vadjustment().connect("value-changed", self._sync_vscroll, i)

w.get_hadjustment().connect("value-changed", self._sync_hscroll)

# Revert overlay scrolling that messes with widget interactivity

if hasattr(w, 'set_overlay_scrolling'):

w.set_overlay_scrolling(False)

self._connect_buffer_handlers()

self._sync_vscroll_lock = False

self._sync_hscroll_lock = False

self._scroll_lock = False

self.linediffer = self.differ()

self.force_highlight = False

self.syncpoints = []

self.in_nested_textview_gutter_expose = False

self._cached_match = CachedSequenceMatcher()

self.anim_source_id = [None for buf in self.textbuffer]

self.animating_chunks = [[] for buf in self.textbuffer]

for buf in self.textbuffer:

buf.create_tag("inline")

buf.connect("notify::has-selection",

self.update_text_actions_sensitivity)

self.ui_file = gnomeglade.ui_file("filediff-ui.xml")

self.actiongroup = self.FilediffActions

self.actiongroup.set_translation_domain("meld")

self.findbar = findbar.FindBar(self.grid)

self.grid.attach(self.findbar.widget, 1, 2, 5, 1)

self.widget.ensure_style()

self.on_style_updated(self.widget)

self.widget.connect("style-updated", self.on_style_updated)

self.set_num_panes(num_panes)

self.cursor = CursorDetails()

self.connect("current-diff-changed", self.on_current_diff_changed)

for t in self.textview:

t.connect("focus-in-event", self.on_current_diff_changed)

t.connect("focus-out-event", self.on_current_diff_changed)

self.linediffer.connect("diffs-changed", self.on_diffs_changed)

self.undosequence.connect("checkpointed", self.on_undo_checkpointed)

self.connect("next-conflict-changed", self.on_next_conflict_changed)

for diffmap in self.diffmap:

self.linediffer.connect('diffs-changed', diffmap.on_diffs_changed)

overwrite_label = Gtk.Label()

overwrite_label.show()

cursor_label = Gtk.Label()

cursor_label.show()

self.status_info_labels = [overwrite_label, cursor_label]

self.statusbar.set_info_box(self.status_info_labels)

# Prototype implementation

from meld.gutterrendererchunk import GutterRendererChunkAction

for pane, t in enumerate(self.textview):

# FIXME: set_num_panes will break this good

direction = t.get_direction()

if pane == 0 or (pane == 1 and self.num_panes == 3):

window = Gtk.TextWindowType.RIGHT

if direction == Gtk.TextDirection.RTL:

window = Gtk.TextWindowType.LEFT

views = [self.textview[pane], self.textview[pane + 1]]

renderer = GutterRendererChunkAction(pane, pane + 1, views, self, self.linediffer)

gutter = t.get_gutter(window)

gutter.insert(renderer, 10)

if pane in (1, 2):

window = Gtk.TextWindowType.LEFT

if direction == Gtk.TextDirection.RTL:

window = Gtk.TextWindowType.RIGHT

views = [self.textview[pane], self.textview[pane - 1]]

renderer = GutterRendererChunkAction(pane, pane - 1, views, self, self.linediffer)

gutter = t.get_gutter(window)

gutter.insert(renderer, -40)

self.connect("notify::ignore-blank-lines", self.refresh_comparison)

meldsettings.connect('changed', self.on_setting_changed)

def get_keymask(self):

return self._keymask

def set_keymask(self, value):

if value & MASK_SHIFT:

mode = MODE_DELETE

elif value & MASK_CTRL:

mode = MODE_INSERT

else:

mode = MODE_REPLACE

self._keymask = value

self.emit("action-mode-changed", mode)

keymask = property(get_keymask, set_keymask)

def on_key_event(self, object, event):

keymap = Gdk.Keymap.get_default()

ok, keyval, group, lvl, consumed = keymap.translate_keyboard_state(

event.hardware_keycode, 0, event.group)

mod_key = self.keylookup.get(keyval, 0)

if event.type == Gdk.EventType.KEY_PRESS:

self.keymask |= mod_key

if event.keyval == Gdk.KEY_Escape:

self.findbar.hide()

elif event.type == Gdk.EventType.KEY_RELEASE:

if event.keyval == Gdk.KEY_Return and self.keymask & MASK_SHIFT:

self.findbar.start_find_previous(self.focus_pane)

self.keymask &= ~mod_key

def on_style_updated(self, widget):

style = widget.get_style_context()

def lookup(name, default):

found, colour = style.lookup_color(name)

if not found:

colour = Gdk.RGBA()

colour.parse(default)

return colour

for buf in self.textbuffer:

tag = buf.get_tag_table().lookup("inline")

tag.props.background_rgba = lookup("inline-bg", "LightSteelBlue2")

override_bg = style.lookup_color("override-background-color")

self.override_bg = override_bg[1] if override_bg[0] else None

self.fill_colors = {"insert" : lookup("insert-bg", "DarkSeaGreen1"),

"delete" : lookup("insert-bg", "DarkSeaGreen1"),

"conflict": lookup("conflict-bg", "Pink"),

"replace" : lookup("replace-bg", "#ddeeff"),

"current-chunk-highlight":

lookup("current-chunk-highlight", '#ffffff')}

self.line_colors = {"insert" : lookup("insert-outline", "#77f077"),

"delete" : lookup("insert-outline", "#77f077"),

"conflict": lookup("conflict-outline", "#f0768b"),

"replace" : lookup("replace-outline", "#8bbff3")}

self.highlight_color = lookup("current-line-highlight", "#ffff00")

self.syncpoint_color = lookup("syncpoint-outline", "#555555")

for associated in self.diffmap + self.linkmap:

associated.set_color_scheme([self.fill_colors, self.line_colors])

self.queue_draw()

def on_focus_change(self):

self.keymask = 0

def on_text_filters_changed(self, app):

relevant_change = self.create_text_filters()

if relevant_change:

self.refresh_comparison()

def create_text_filters(self):

# In contrast to file filters, ordering of text filters can matter

old_active = [f.filter_string for f in self.text_filters if f.active]

new_active = [f.filter_string for f in meldsettings.text_filters

if f.active]

active_filters_changed = old_active != new_active

self.text_filters = [copy.copy(f) for f in meldsettings.text_filters]

return active_filters_changed

def _disconnect_buffer_handlers(self):

for textview in self.textview:

textview.set_editable(0)

for buf in self.textbuffer:

assert hasattr(buf,"handlers")

for h in buf.handlers:

buf.disconnect(h)

def _connect_buffer_handlers(self):

for textview, buf in zip(self.textview, self.textbuffer):

textview.set_editable(buf.data.editable)

for buf in self.textbuffer:

id0 = buf.connect("insert-text", self.on_text_insert_text)

id1 = buf.connect("delete-range", self.on_text_delete_range)

id2 = buf.connect_after("insert-text", self.after_text_insert_text)

id3 = buf.connect_after("delete-range", self.after_text_delete_range)

id4 = buf.connect("notify::cursor-position",

self.on_cursor_position_changed)

buf.handlers = id0, id1, id2, id3, id4

# Abbreviations for insert and overwrite that fit in the status bar

_insert_overwrite_text = (_("INS"), _("OVR"))

# Abbreviation for line, column so that it will fit in the status bar

_line_column_text = _("Ln %i, Col %i")

def on_cursor_position_changed(self, buf, pspec, force=False):

pane = self.textbuffer.index(buf)

pos = buf.props.cursor_position

if pane == self.cursor.pane and pos == self.cursor.pos and not force:

return

self.cursor.pane, self.cursor.pos = pane, pos

cursor_it = buf.get_iter_at_offset(pos)

offset = cursor_it.get_line_offset()

line = cursor_it.get_line()

insert_overwrite = self._insert_overwrite_text[self.textview_overwrite]

line_column = self._line_column_text % (line + 1, offset + 1)

self.status_info_labels[0].set_text(insert_overwrite)

self.status_info_labels[1].set_text(line_column)

if line != self.cursor.line or force:

chunk, prev, next_ = self.linediffer.locate_chunk(pane, line)

if chunk != self.cursor.chunk or force:

self.cursor.chunk = chunk

self.emit("current-diff-changed")

if prev != self.cursor.prev or next_ != self.cursor.next or force:

self.emit("next-diff-changed", prev is not None,

next_ is not None)

prev_conflict, next_conflict = None, None

for conflict in self.linediffer.conflicts:

if prev is not None and conflict <= prev:

prev_conflict = conflict

if next_ is not None and conflict >= next_:

next_conflict = conflict

break

if prev_conflict != self.cursor.prev_conflict or \

next_conflict != self.cursor.next_conflict or force:

self.emit("next-conflict-changed", prev_conflict is not None,

next_conflict is not None)

self.cursor.prev, self.cursor.next = prev, next_

self.cursor.prev_conflict = prev_conflict

self.cursor.next_conflict = next_conflict

self.cursor.line, self.cursor.offset = line, offset

def on_current_diff_changed(self, widget, *args):

pane = self._get_focused_pane()

if pane != -1:

# While this *should* be redundant, it's possible for focus pane

# and cursor pane to be different in several situations.

pane = self.cursor.pane

chunk_id = self.cursor.chunk

if pane == -1 or chunk_id is None:

push_left, push_right, pull_left, pull_right, delete, \

copy_left, copy_right = (False,) * 7

else:

push_left, push_right, pull_left, pull_right, delete, \

copy_left, copy_right = (True,) * 7

# Push and Delete are active if the current pane has something to

# act on, and the target pane exists and is editable. Pull is

# sensitive if the source pane has something to get, and the

# current pane is editable. Copy actions are sensitive if the

# conditions for push are met, *and* there is some content in the

# target pane.

editable = self.textview[pane].get_editable()

editable_left = pane > 0 and self.textview[pane - 1].get_editable()

editable_right = pane < self.num_panes - 1 and \

self.textview[pane + 1].get_editable()

if pane == 0 or pane == 2:

chunk = self.linediffer.get_chunk(chunk_id, pane)

insert_chunk = chunk[1] == chunk[2]

delete_chunk = chunk[3] == chunk[4]

push_left = editable_left

push_right = editable_right

pull_left = pane == 2 and editable and not delete_chunk

pull_right = pane == 0 and editable and not delete_chunk

delete = editable and not insert_chunk

copy_left = editable_left and not (insert_chunk or delete_chunk)

copy_right = editable_right and not (insert_chunk or delete_chunk)

elif pane == 1:

chunk0 = self.linediffer.get_chunk(chunk_id, 1, 0)

chunk2 = None

if self.num_panes == 3:

chunk2 = self.linediffer.get_chunk(chunk_id, 1, 2)

left_mid_exists = chunk0 is not None and chunk0[1] != chunk0[2]

left_exists = chunk0 is not None and chunk0[3] != chunk0[4]

right_mid_exists = chunk2 is not None and chunk2[1] != chunk2[2]

right_exists = chunk2 is not None and chunk2[3] != chunk2[4]

push_left = editable_left

push_right = editable_right

pull_left = editable and left_exists

pull_right = editable and right_exists

delete = editable and (left_mid_exists or right_mid_exists)

copy_left = editable_left and left_mid_exists and left_exists

copy_right = editable_right and right_mid_exists and right_exists

self.actiongroup.get_action("PushLeft").set_sensitive(push_left)

self.actiongroup.get_action("PushRight").set_sensitive(push_right)

self.actiongroup.get_action("PullLeft").set_sensitive(pull_left)

self.actiongroup.get_action("PullRight").set_sensitive(pull_right)

self.actiongroup.get_action("Delete").set_sensitive(delete)

self.actiongroup.get_action("CopyLeftUp").set_sensitive(copy_left)

self.actiongroup.get_action("CopyLeftDown").set_sensitive(copy_left)

self.actiongroup.get_action("CopyRightUp").set_sensitive(copy_right)

self.actiongroup.get_action("CopyRightDown").set_sensitive(copy_right)

prev_pane = pane > 0

next_pane = pane < self.num_panes - 1

self.actiongroup.get_action("PrevPane").set_sensitive(prev_pane)

self.actiongroup.get_action("NextPane").set_sensitive(next_pane)

# FIXME: don't queue_draw() on everything... just on what changed

self.queue_draw()

def on_next_conflict_changed(self, doc, have_prev, have_next):

self.actiongroup.get_action("PrevConflict").set_sensitive(have_prev)

self.actiongroup.get_action("NextConflict").set_sensitive(have_next)

def go_to_chunk(self, target, pane=None, centered=False):

if target is None:

return

if pane is None:

pane = self._get_focused_pane()

if pane == -1:

pane = 1 if len(self.textview) > 1 else 0

chunk = self.linediffer.get_chunk(target, pane)

if not chunk:

return

# Warp the cursor to the first line of the chunk

buf = self.textbuffer[pane]

if self.cursor.line != chunk[1]:

buf.place_cursor(buf.get_iter_at_line(chunk[1]))

tolerance = 0.0 if centered else 0.2

self.textview[pane].scroll_to_mark(

buf.get_insert(), tolerance, True, 0.5, 0.5)

def next_diff(self, direction, centered=False):

target = (self.cursor.next if direction == Gdk.ScrollDirection.DOWN

else self.cursor.prev)

self.go_to_chunk(target, centered=centered)

def action_previous_conflict(self, *args):

self.go_to_chunk(self.cursor.prev_conflict, self.cursor.pane)

def action_next_conflict(self, *args):

self.go_to_chunk(self.cursor.next_conflict, self.cursor.pane)

def action_previous_diff(self, *args):

self.go_to_chunk(self.cursor.prev)

def action_next_diff(self, *args):

self.go_to_chunk(self.cursor.next)

def get_action_chunk(self, src, dst):

valid_panes = list(range(0, self.num_panes))

if (src not in valid_panes or dst not in valid_panes or

self.cursor.chunk is None):

raise ValueError("Action was taken on invalid panes")

chunk = self.linediffer.get_chunk(self.cursor.chunk, src, dst)

if chunk is None:

raise ValueError("Action was taken on a missing chunk")

return chunk

def get_action_panes(self, direction, reverse=False):

src = self._get_focused_pane()

dst = src + direction

return (dst, src) if reverse else (src, dst)

def action_push_change_left(self, *args):

src, dst = self.get_action_panes(PANE_LEFT)

self.replace_chunk(src, dst, self.get_action_chunk(src, dst))

def action_push_change_right(self, *args):

src, dst = self.get_action_panes(PANE_RIGHT)

self.replace_chunk(src, dst, self.get_action_chunk(src, dst))

def action_pull_change_left(self, *args):

src, dst = self.get_action_panes(PANE_LEFT, reverse=True)

self.replace_chunk(src, dst, self.get_action_chunk(src, dst))

def action_pull_change_right(self, *args):

src, dst = self.get_action_panes(PANE_RIGHT, reverse=True)

self.replace_chunk(src, dst, self.get_action_chunk(src, dst))

def action_copy_change_left_up(self, *args):

src, dst = self.get_action_panes(PANE_LEFT)

self.copy_chunk(

src, dst, self.get_action_chunk(src, dst), copy_up=True)

def action_copy_change_right_up(self, *args):

src, dst = self.get_action_panes(PANE_RIGHT)

self.copy_chunk(

src, dst, self.get_action_chunk(src, dst), copy_up=True)

def action_copy_change_left_down(self, *args):

src, dst = self.get_action_panes(PANE_LEFT)

self.copy_chunk(

src, dst, self.get_action_chunk(src, dst), copy_up=False)

def action_copy_change_right_down(self, *args):

src, dst = self.get_action_panes(PANE_RIGHT)

self.copy_chunk(

src, dst, self.get_action_chunk(src, dst), copy_up=False)

def pull_all_non_conflicting_changes(self, src, dst):

merger = merge.Merger()

merger.differ = self.linediffer

merger.texts = self.buffer_texts

for mergedfile in merger.merge_2_files(src, dst):

pass

self._sync_vscroll_lock = True

self.on_textbuffer_begin_user_action()

self.textbuffer[dst].set_text(mergedfile)

self.on_textbuffer_end_user_action()

def resync():

self._sync_vscroll_lock = False

self._sync_vscroll(self.scrolledwindow[src].get_vadjustment(), src)

self.scheduler.add_task(resync)

def action_pull_all_changes_left(self, *args):

src, dst = self.get_action_panes(PANE_LEFT, reverse=True)

self.pull_all_non_conflicting_changes(src, dst)

def action_pull_all_changes_right(self, *args):

src, dst = self.get_action_panes(PANE_RIGHT, reverse=True)

self.pull_all_non_conflicting_changes(src, dst)

def merge_all_non_conflicting_changes(self):

dst = 1

merger = merge.Merger()

merger.differ = self.linediffer

merger.texts = self.buffer_texts

for mergedfile in merger.merge_3_files(False):

pass

self._sync_vscroll_lock = True

self.on_textbuffer_begin_user_action()

self.textbuffer[dst].set_text(mergedfile)

self.on_textbuffer_end_user_action()

def resync():

self._sync_vscroll_lock = False

self._sync_vscroll(self.scrolledwindow[0].get_vadjustment(), 0)

self.scheduler.add_task(resync)

def delete_change(self, widget):

pane = self._get_focused_pane()

chunk = self.linediffer.get_chunk(self.cursor.chunk, pane)

assert(pane != -1 and self.cursor.chunk is not None)

assert(chunk is not None)

self.delete_chunk(pane, chunk)

def _synth_chunk(self, pane0, pane1, line):

"""Returns the Same chunk that would exist at

the given location if we didn't remove Same chunks"""

# This method is a hack around our existing diffutil data structures;

# getting rid of the Same chunk removal is difficult, as several places

# have baked in the assumption of only being given changed blocks.

buf0, buf1 = self.textbuffer[pane0], self.textbuffer[pane1]

start0, end0 = 0, buf0.get_line_count() - 1

start1, end1 = 0, buf1.get_line_count() - 1

# This hack is required when pane0's prev/next chunk doesn't exist

# (i.e., is Same) between pane0 and pane1.

prev_chunk0, prev_chunk1, next_chunk0, next_chunk1 = (None,) * 4

_, prev, next_ = self.linediffer.locate_chunk(pane0, line)

if prev is not None:

while prev >= 0:

prev_chunk0 = self.linediffer.get_chunk(prev, pane0, pane1)

prev_chunk1 = self.linediffer.get_chunk(prev, pane1, pane0)

if None not in (prev_chunk0, prev_chunk1):

start0 = prev_chunk0[2]

start1 = prev_chunk1[2]

break

prev -= 1

if next_ is not None:

while next_ < self.linediffer.diff_count():

next_chunk0 = self.linediffer.get_chunk(next_, pane0, pane1)

next_chunk1 = self.linediffer.get_chunk(next_, pane1, pane0)

if None not in (next_chunk0, next_chunk1):

end0 = next_chunk0[1]

end1 = next_chunk1[1]

break

next_ += 1

return "Same", start0, end0, start1, end1

def _corresponding_chunk_line(self, chunk, line, pane, new_pane):

"""Approximates the corresponding line between panes"""

old_buf, new_buf = self.textbuffer[pane], self.textbuffer[new_pane]

# Special-case cross-pane jumps

if (pane == 0 and new_pane == 2) or (pane == 2 and new_pane == 0):

proxy = self._corresponding_chunk_line(chunk, line, pane, 1)

return self._corresponding_chunk_line(chunk, proxy, 1, new_pane)

# Either we are currently in a identifiable chunk, or we are in a Same

# chunk; if we establish the start/end of that chunk in both panes, we

# can figure out what our new offset should be.

cur_chunk = None

if chunk is not None:

cur_chunk = self.linediffer.get_chunk(chunk, pane, new_pane)

if cur_chunk is None:

cur_chunk = self._synth_chunk(pane, new_pane, line)

cur_start, cur_end, new_start, new_end = cur_chunk[1:5]

# If the new buffer's current cursor is already in the correct chunk,

# assume that we have in-progress editing, and don't move it.

cursor_it = new_buf.get_iter_at_mark(new_buf.get_insert())

cursor_line = cursor_it.get_line()

cursor_chunk, _, _ = self.linediffer.locate_chunk(new_pane, cursor_line)

if cursor_chunk is not None:

already_in_chunk = cursor_chunk == chunk

else:

cursor_chunk = self._synth_chunk(pane, new_pane, cursor_line)

already_in_chunk = cursor_chunk[3] == new_start and \

cursor_chunk[4] == new_end

if already_in_chunk:

new_line = cursor_line

else:

# Guess where to put the cursor: in the same chunk, at about the

# same place within the chunk, calculated proportionally by line.

# Insert chunks and one-line chunks are placed at the top.

if cur_end == cur_start:

chunk_offset = 0.0

else:

chunk_offset = (line - cur_start) / float(cur_end - cur_start)

new_line = new_start + int(chunk_offset * (new_end - new_start))

return new_line

def move_cursor_pane(self, pane, new_pane):

chunk, line = self.cursor.chunk, self.cursor.line

new_line = self._corresponding_chunk_line(chunk, line, pane, new_pane)

new_buf = self.textbuffer[new_pane]

self.textview[new_pane].grab_focus()

new_buf.place_cursor(new_buf.get_iter_at_line(new_line))

self.textview[new_pane].scroll_to_mark(

new_buf.get_insert(), 0.1, True, 0.5, 0.5)

def action_prev_pane(self, *args):

pane = self._get_focused_pane()

new_pane = (pane - 1) % self.num_panes

self.move_cursor_pane(pane, new_pane)

def action_next_pane(self, *args):

pane = self._get_focused_pane()

new_pane = (pane + 1) % self.num_panes

self.move_cursor_pane(pane, new_pane)

def _set_external_action_sensitivity(self):

have_file = self.focus_pane is not None

try:

self.main_actiongroup.get_action("OpenExternal").set_sensitive(

have_file)

except AttributeError:

pass

def on_textview_focus_in_event(self, view, event):

self.focus_pane = view

self.findbar.textview = view

self.on_cursor_position_changed(view.get_buffer(), None, True)

self._set_save_action_sensitivity()

self._set_merge_action_sensitivity()

self._set_external_action_sensitivity()

self.update_text_actions_sensitivity()

def on_textview_focus_out_event(self, view, event):

self._set_merge_action_sensitivity()

self._set_external_action_sensitivity()

def _after_text_modified(self, buffer, startline, sizechange):

if self.num_panes > 1:

pane = self.textbuffer.index(buffer)

if not self.linediffer.syncpoints:

self.linediffer.change_sequence(pane, startline, sizechange,

self.buffer_filtered)

# FIXME: diff-changed signal for the current buffer would be cleaner

focused_pane = self._get_focused_pane()

if focused_pane != -1:

self.on_cursor_position_changed(self.textbuffer[focused_pane],

None, True)

self.queue_draw()

def _filter_text(self, txt):

def killit(m):

assert m.group().count("\n") == 0

if len(m.groups()):

s = m.group()

for g in m.groups():

if g:

s = s.replace(g,"")

return s

else:

return ""

try:

for filt in self.text_filters:

if filt.active:

txt = filt.filter.sub(killit, txt)

except AssertionError:

if not self.warned_bad_comparison:

misc.error_dialog(

primary=_(u"Comparison results will be inaccurate"),

secondary=_(

u"Filter “%s” changed the number of lines in the "

u"file, which is unsupported. The comparison will "

u"not be accurate.") % filt.label,

)

self.warned_bad_comparison = True

return txt

def after_text_insert_text(self, buf, it, newtext, textlen):

start_mark = buf.get_mark("insertion-start")

starting_at = buf.get_iter_at_mark(start_mark).get_line()

buf.delete_mark(start_mark)

lines_added = it.get_line() - starting_at

self._after_text_modified(buf, starting_at, lines_added)

def after_text_delete_range(self, buffer, it0, it1):

starting_at = it0.get_line()

assert self.deleted_lines_pending != -1

self._after_text_modified(buffer, starting_at, -self.deleted_lines_pending)

self.deleted_lines_pending = -1

def load_font(self):

context = self.textview0.get_pango_context()

metrics = context.get_metrics(meldsettings.font,

context.get_language())

line_height_points = metrics.get_ascent() + metrics.get_descent()

self.pixels_per_line = line_height_points // 1024

for i in range(3):

self.textview[i].override_font(meldsettings.font)

for i in range(2):

self.linkmap[i].queue_draw()

def on_setting_changed(self, settings, key):

if key == 'font':

self.load_font()

def check_save_modified(self):

response = Gtk.ResponseType.OK

modified = [b.data.modified for b in self.textbuffer[:self.num_panes]]

labels = [b.data.label for b in self.textbuffer[:self.num_panes]]

if True in modified:

dialog = gnomeglade.Component("filediff.ui", "check_save_dialog")

dialog.widget.set_transient_for(self.widget.get_toplevel())

message_area = dialog.widget.get_message_area()

buttons = []

for label, should_save in zip(labels, modified):

button = Gtk.CheckButton.new_with_label(label)

button.set_sensitive(should_save)

button.set_active(should_save)

message_area.pack_start(

button, expand=False, fill=True, padding=0)

buttons.append(button)

message_area.show_all()

response = dialog.widget.run()

try_save = [b.get_active() for b in buttons]

dialog.widget.destroy()

if response == Gtk.ResponseType.OK:

for i in range(self.num_panes):

if try_save[i]:

if not self.save_file(i):

return Gtk.ResponseType.CANCEL

elif response == Gtk.ResponseType.DELETE_EVENT:

response = Gtk.ResponseType.CANCEL

if response == Gtk.ResponseType.CLOSE:

response = Gtk.ResponseType.OK

if response == Gtk.ResponseType.OK and self.meta:

parent = self.meta.get('parent', None)

saved = self.meta.get('middle_saved', False)

prompt_resolve = self.meta.get('prompt_resolve', False)

if prompt_resolve and saved and parent.has_command('resolve'):

primary = _("Mark conflict as resolved?")

secondary = _(

"If the conflict was resolved successfully, you may mark "

"it as resolved now.")

buttons = ((_("Cancel"), Gtk.ResponseType.CANCEL),

(_("Mark _Resolved"), Gtk.ResponseType.OK))

resolve_response = misc.modal_dialog(

primary, secondary, buttons, parent=self.widget,

messagetype=Gtk.MessageType.QUESTION)

if resolve_response == Gtk.ResponseType.OK:

conflict_file = self.textbuffer[1].data.filename

parent.command('resolve', [conflict_file])

return response

def on_delete_event(self, appquit=0):

response = self.check_save_modified()

if response == Gtk.ResponseType.OK:

for h in self.settings_handlers:

meldsettings.disconnect(h)

# TODO: Base the return code on something meaningful for VC tools

self.emit('close', 0)

return response

def on_undo_activate(self):

if self.undosequence.can_undo():

self.undosequence.undo()

def on_redo_activate(self):

if self.undosequence.can_redo():

self.undosequence.redo()

def on_textbuffer_begin_user_action(self, *buffer):

self.undosequence.begin_group()

def on_textbuffer_end_user_action(self, *buffer):

self.undosequence.end_group()

def on_text_insert_text(self, buf, it, text, textlen):

text = text_type(text, 'utf8')

self.undosequence.add_action(

meldbuffer.BufferInsertionAction(buf, it.get_offset(), text))

buf.create_mark("insertion-start", it, True)

def on_text_delete_range(self, buf, it0, it1):

text = text_type(buf.get_text(it0, it1, False), 'utf8')

assert self.deleted_lines_pending == -1

self.deleted_lines_pending = it1.get_line() - it0.get_line()

self.undosequence.add_action(

meldbuffer.BufferDeletionAction(buf, it0.get_offset(), text))

def on_undo_checkpointed(self, undosequence, buf, checkpointed):

self.set_buffer_modified(buf, not checkpointed)

def open_external(self):

pane = self._get_focused_pane()

if pane >= 0:

if self.textbuffer[pane].data.filename:

pos = self.textbuffer[pane].props.cursor_position

cursor_it = self.textbuffer[pane].get_iter_at_offset(pos)

line = cursor_it.get_line() + 1

self._open_files([self.textbuffer[pane].data.filename], line)

def update_text_actions_sensitivity(self, *args):

widget = self.focus_pane

if not widget:

cut, copy, paste = False, False, False

else:

cut = copy = widget.get_buffer().get_has_selection()

# Ideally, this would check whether the clipboard included

# something pasteable. However, there is no changed signal.

# widget.get_clipboard(

# Gdk.SELECTION_CLIPBOARD).wait_is_text_available()

paste = widget.get_editable()

if self.main_actiongroup:

for action, sens in zip(

("Cut", "Copy", "Paste"), (cut, copy, paste)):

self.main_actiongroup.get_action(action).set_sensitive(sens)

def get_selected_text(self):

"""Returns selected text of active pane"""

pane = self._get_focused_pane()

if pane != -1:

buf = self.textbuffer[pane]

sel = buf.get_selection_bounds()

if sel:

return text_type(buf.get_text(sel[0], sel[1], False), 'utf8')

return None

def on_find_activate(self, *args):

selected_text = self.get_selected_text()

self.findbar.start_find(self.focus_pane, selected_text)

self.keymask = 0

def on_replace_activate(self, *args):

selected_text = self.get_selected_text()

self.findbar.start_replace(self.focus_pane, selected_text)

self.keymask = 0

def on_find_next_activate(self, *args):

self.findbar.start_find_next(self.focus_pane)

def on_find_previous_activate(self, *args):