[Summary view] [Print] [Text view]

   1  // CodeMirror, copyright (c) by Marijn Haverbeke and others
   2  // Distributed under an MIT license: https://codemirror.net/5/LICENSE
   3  
   4  // declare global: diff_match_patch, DIFF_INSERT, DIFF_DELETE, DIFF_EQUAL
   5  
   6  (function(mod) {
   7    if (typeof exports == "object" && typeof module == "object") // CommonJS
   8      mod(require("../../lib/codemirror")); // Note non-packaged dependency diff_match_patch
   9    else if (typeof define == "function" && define.amd) // AMD
  10      define(["../../lib/codemirror", "diff_match_patch"], mod);
  11    else // Plain browser env
  12      mod(CodeMirror);
  13  })(function(CodeMirror) {
  14    "use strict";
  15    var Pos = CodeMirror.Pos;
  16    var svgNS = "http://www.w3.org/2000/svg";
  17  
  18    function DiffView(mv, type) {
  19      this.mv = mv;
  20      this.type = type;
  21      this.classes = type == "left"
  22        ? {chunk: "CodeMirror-merge-l-chunk",
  23           start: "CodeMirror-merge-l-chunk-start",
  24           end: "CodeMirror-merge-l-chunk-end",
  25           insert: "CodeMirror-merge-l-inserted",
  26           del: "CodeMirror-merge-l-deleted",
  27           connect: "CodeMirror-merge-l-connect"}
  28        : {chunk: "CodeMirror-merge-r-chunk",
  29           start: "CodeMirror-merge-r-chunk-start",
  30           end: "CodeMirror-merge-r-chunk-end",
  31           insert: "CodeMirror-merge-r-inserted",
  32           del: "CodeMirror-merge-r-deleted",
  33           connect: "CodeMirror-merge-r-connect"};
  34    }
  35  
  36    DiffView.prototype = {
  37      constructor: DiffView,
  38      init: function(pane, orig, options) {
  39        this.edit = this.mv.edit;
  40        ;(this.edit.state.diffViews || (this.edit.state.diffViews = [])).push(this);
  41        this.orig = CodeMirror(pane, copyObj({value: orig, readOnly: !this.mv.options.allowEditingOriginals}, copyObj(options)));
  42        if (this.mv.options.connect == "align") {
  43          if (!this.edit.state.trackAlignable) this.edit.state.trackAlignable = new TrackAlignable(this.edit)
  44          this.orig.state.trackAlignable = new TrackAlignable(this.orig)
  45        }
  46        this.lockButton.title = this.edit.phrase("Toggle locked scrolling");
  47        this.lockButton.setAttribute("aria-label", this.lockButton.title);
  48  
  49        this.orig.state.diffViews = [this];
  50        var classLocation = options.chunkClassLocation || "background";
  51        if (Object.prototype.toString.call(classLocation) != "[object Array]") classLocation = [classLocation]
  52        this.classes.classLocation = classLocation
  53  
  54        this.diff = getDiff(asString(orig), asString(options.value), this.mv.options.ignoreWhitespace);
  55        this.chunks = getChunks(this.diff);
  56        this.diffOutOfDate = this.dealigned = false;
  57        this.needsScrollSync = null
  58  
  59        this.showDifferences = options.showDifferences !== false;
  60      },
  61      registerEvents: function(otherDv) {
  62        this.forceUpdate = registerUpdate(this);
  63        setScrollLock(this, true, false);
  64        registerScroll(this, otherDv);
  65      },
  66      setShowDifferences: function(val) {
  67        val = val !== false;
  68        if (val != this.showDifferences) {
  69          this.showDifferences = val;
  70          this.forceUpdate("full");
  71        }
  72      }
  73    };
  74  
  75    function ensureDiff(dv) {
  76      if (dv.diffOutOfDate) {
  77        dv.diff = getDiff(dv.orig.getValue(), dv.edit.getValue(), dv.mv.options.ignoreWhitespace);
  78        dv.chunks = getChunks(dv.diff);
  79        dv.diffOutOfDate = false;
  80        CodeMirror.signal(dv.edit, "updateDiff", dv.diff);
  81      }
  82    }
  83  
  84    var updating = false;
  85    function registerUpdate(dv) {
  86      var edit = {from: 0, to: 0, marked: []};
  87      var orig = {from: 0, to: 0, marked: []};
  88      var debounceChange, updatingFast = false;
  89      function update(mode) {
  90        updating = true;
  91        updatingFast = false;
  92        if (mode == "full") {
  93          if (dv.svg) clear(dv.svg);
  94          if (dv.copyButtons) clear(dv.copyButtons);
  95          clearMarks(dv.edit, edit.marked, dv.classes);
  96          clearMarks(dv.orig, orig.marked, dv.classes);
  97          edit.from = edit.to = orig.from = orig.to = 0;
  98        }
  99        ensureDiff(dv);
 100        if (dv.showDifferences) {
 101          updateMarks(dv.edit, dv.diff, edit, DIFF_INSERT, dv.classes);
 102          updateMarks(dv.orig, dv.diff, orig, DIFF_DELETE, dv.classes);
 103        }
 104  
 105        if (dv.mv.options.connect == "align")
 106          alignChunks(dv);
 107        makeConnections(dv);
 108        if (dv.needsScrollSync != null) syncScroll(dv, dv.needsScrollSync)
 109  
 110        updating = false;
 111      }
 112      function setDealign(fast) {
 113        if (updating) return;
 114        dv.dealigned = true;
 115        set(fast);
 116      }
 117      function set(fast) {
 118        if (updating || updatingFast) return;
 119        clearTimeout(debounceChange);
 120        if (fast === true) updatingFast = true;
 121        debounceChange = setTimeout(update, fast === true ? 20 : 250);
 122      }
 123      function change(_cm, change) {
 124        if (!dv.diffOutOfDate) {
 125          dv.diffOutOfDate = true;
 126          edit.from = edit.to = orig.from = orig.to = 0;
 127        }
 128        // Update faster when a line was added/removed
 129        setDealign(change.text.length - 1 != change.to.line - change.from.line);
 130      }
 131      function swapDoc() {
 132        dv.diffOutOfDate = true;
 133        dv.dealigned = true;
 134        update("full");
 135      }
 136      dv.edit.on("change", change);
 137      dv.orig.on("change", change);
 138      dv.edit.on("swapDoc", swapDoc);
 139      dv.orig.on("swapDoc", swapDoc);
 140      if (dv.mv.options.connect == "align") {
 141        CodeMirror.on(dv.edit.state.trackAlignable, "realign", setDealign)
 142        CodeMirror.on(dv.orig.state.trackAlignable, "realign", setDealign)
 143      }
 144      dv.edit.on("viewportChange", function() { set(false); });
 145      dv.orig.on("viewportChange", function() { set(false); });
 146      update();
 147      return update;
 148    }
 149  
 150    function registerScroll(dv, otherDv) {
 151      dv.edit.on("scroll", function() {
 152        syncScroll(dv, true) && makeConnections(dv);
 153      });
 154      dv.orig.on("scroll", function() {
 155        syncScroll(dv, false) && makeConnections(dv);
 156        if (otherDv) syncScroll(otherDv, true) && makeConnections(otherDv);
 157      });
 158    }
 159  
 160    function syncScroll(dv, toOrig) {
 161      // Change handler will do a refresh after a timeout when diff is out of date
 162      if (dv.diffOutOfDate) {
 163        if (dv.lockScroll && dv.needsScrollSync == null) dv.needsScrollSync = toOrig
 164        return false
 165      }
 166      dv.needsScrollSync = null
 167      if (!dv.lockScroll) return true;
 168      var editor, other, now = +new Date;
 169      if (toOrig) { editor = dv.edit; other = dv.orig; }
 170      else { editor = dv.orig; other = dv.edit; }
 171      // Don't take action if the position of this editor was recently set
 172      // (to prevent feedback loops)
 173      if (editor.state.scrollSetBy == dv && (editor.state.scrollSetAt || 0) + 250 > now) return false;
 174  
 175      var sInfo = editor.getScrollInfo();
 176      if (dv.mv.options.connect == "align") {
 177        targetPos = sInfo.top;
 178      } else {
 179        var halfScreen = .5 * sInfo.clientHeight, midY = sInfo.top + halfScreen;
 180        var mid = editor.lineAtHeight(midY, "local");
 181        var around = chunkBoundariesAround(dv.chunks, mid, toOrig);
 182        var off = getOffsets(editor, toOrig ? around.edit : around.orig);
 183        var offOther = getOffsets(other, toOrig ? around.orig : around.edit);
 184        var ratio = (midY - off.top) / (off.bot - off.top);
 185        var targetPos = (offOther.top - halfScreen) + ratio * (offOther.bot - offOther.top);
 186  
 187        var botDist, mix;
 188        // Some careful tweaking to make sure no space is left out of view
 189        // when scrolling to top or bottom.
 190        if (targetPos > sInfo.top && (mix = sInfo.top / halfScreen) < 1) {
 191          targetPos = targetPos * mix + sInfo.top * (1 - mix);
 192        } else if ((botDist = sInfo.height - sInfo.clientHeight - sInfo.top) < halfScreen) {
 193          var otherInfo = other.getScrollInfo();
 194          var botDistOther = otherInfo.height - otherInfo.clientHeight - targetPos;
 195          if (botDistOther > botDist && (mix = botDist / halfScreen) < 1)
 196            targetPos = targetPos * mix + (otherInfo.height - otherInfo.clientHeight - botDist) * (1 - mix);
 197        }
 198      }
 199  
 200      other.scrollTo(sInfo.left, targetPos);
 201      other.state.scrollSetAt = now;
 202      other.state.scrollSetBy = dv;
 203      return true;
 204    }
 205  
 206    function getOffsets(editor, around) {
 207      var bot = around.after;
 208      if (bot == null) bot = editor.lastLine() + 1;
 209      return {top: editor.heightAtLine(around.before || 0, "local"),
 210              bot: editor.heightAtLine(bot, "local")};
 211    }
 212  
 213    function setScrollLock(dv, val, action) {
 214      dv.lockScroll = val;
 215      if (val && action != false) syncScroll(dv, DIFF_INSERT) && makeConnections(dv);
 216      (val ? CodeMirror.addClass : CodeMirror.rmClass)(dv.lockButton, "CodeMirror-merge-scrolllock-enabled");
 217    }
 218  
 219    // Updating the marks for editor content
 220  
 221    function removeClass(editor, line, classes) {
 222      var locs = classes.classLocation
 223      for (var i = 0; i < locs.length; i++) {
 224        editor.removeLineClass(line, locs[i], classes.chunk);
 225        editor.removeLineClass(line, locs[i], classes.start);
 226        editor.removeLineClass(line, locs[i], classes.end);
 227      }
 228    }
 229  
 230    function clearMarks(editor, arr, classes) {
 231      for (var i = 0; i < arr.length; ++i) {
 232        var mark = arr[i];
 233        if (mark instanceof CodeMirror.TextMarker)
 234          mark.clear();
 235        else if (mark.parent)
 236          removeClass(editor, mark, classes);
 237      }
 238      arr.length = 0;
 239    }
 240  
 241    // FIXME maybe add a margin around viewport to prevent too many updates
 242    function updateMarks(editor, diff, state, type, classes) {
 243      var vp = editor.getViewport();
 244      editor.operation(function() {
 245        if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {
 246          clearMarks(editor, state.marked, classes);
 247          markChanges(editor, diff, type, state.marked, vp.from, vp.to, classes);
 248          state.from = vp.from; state.to = vp.to;
 249        } else {
 250          if (vp.from < state.from) {
 251            markChanges(editor, diff, type, state.marked, vp.from, state.from, classes);
 252            state.from = vp.from;
 253          }
 254          if (vp.to > state.to) {
 255            markChanges(editor, diff, type, state.marked, state.to, vp.to, classes);
 256            state.to = vp.to;
 257          }
 258        }
 259      });
 260    }
 261  
 262    function addClass(editor, lineNr, classes, main, start, end) {
 263      var locs = classes.classLocation, line = editor.getLineHandle(lineNr);
 264      for (var i = 0; i < locs.length; i++) {
 265        if (main) editor.addLineClass(line, locs[i], classes.chunk);
 266        if (start) editor.addLineClass(line, locs[i], classes.start);
 267        if (end) editor.addLineClass(line, locs[i], classes.end);
 268      }
 269      return line;
 270    }
 271  
 272    function markChanges(editor, diff, type, marks, from, to, classes) {
 273      var pos = Pos(0, 0);
 274      var top = Pos(from, 0), bot = editor.clipPos(Pos(to - 1));
 275      var cls = type == DIFF_DELETE ? classes.del : classes.insert;
 276      function markChunk(start, end) {
 277        var bfrom = Math.max(from, start), bto = Math.min(to, end);
 278        for (var i = bfrom; i < bto; ++i)
 279          marks.push(addClass(editor, i, classes, true, i == start, i == end - 1));
 280        // When the chunk is empty, make sure a horizontal line shows up
 281        if (start == end && bfrom == end && bto == end) {
 282          if (bfrom)
 283            marks.push(addClass(editor, bfrom - 1, classes, false, false, true));
 284          else
 285            marks.push(addClass(editor, bfrom, classes, false, true, false));
 286        }
 287      }
 288  
 289      var chunkStart = 0, pending = false;
 290      for (var i = 0; i < diff.length; ++i) {
 291        var part = diff[i], tp = part[0], str = part[1];
 292        if (tp == DIFF_EQUAL) {
 293          var cleanFrom = pos.line + (startOfLineClean(diff, i) ? 0 : 1);
 294          moveOver(pos, str);
 295          var cleanTo = pos.line + (endOfLineClean(diff, i) ? 1 : 0);
 296          if (cleanTo > cleanFrom) {
 297            if (pending) { markChunk(chunkStart, cleanFrom); pending = false }
 298            chunkStart = cleanTo;
 299          }
 300        } else {
 301          pending = true
 302          if (tp == type) {
 303            var end = moveOver(pos, str, true);
 304            var a = posMax(top, pos), b = posMin(bot, end);
 305            if (!posEq(a, b))
 306              marks.push(editor.markText(a, b, {className: cls}));
 307            pos = end;
 308          }
 309        }
 310      }
 311      if (pending) markChunk(chunkStart, pos.line + 1);
 312    }
 313  
 314    // Updating the gap between editor and original
 315  
 316    function makeConnections(dv) {
 317      if (!dv.showDifferences) return;
 318  
 319      if (dv.svg) {
 320        clear(dv.svg);
 321        var w = dv.gap.offsetWidth;
 322        attrs(dv.svg, "width", w, "height", dv.gap.offsetHeight);
 323      }
 324      if (dv.copyButtons) clear(dv.copyButtons);
 325  
 326      var vpEdit = dv.edit.getViewport(), vpOrig = dv.orig.getViewport();
 327      var outerTop = dv.mv.wrap.getBoundingClientRect().top
 328      var sTopEdit = outerTop - dv.edit.getScrollerElement().getBoundingClientRect().top + dv.edit.getScrollInfo().top
 329      var sTopOrig = outerTop - dv.orig.getScrollerElement().getBoundingClientRect().top + dv.orig.getScrollInfo().top;
 330      for (var i = 0; i < dv.chunks.length; i++) {
 331        var ch = dv.chunks[i];
 332        if (ch.editFrom <= vpEdit.to && ch.editTo >= vpEdit.from &&
 333            ch.origFrom <= vpOrig.to && ch.origTo >= vpOrig.from)
 334          drawConnectorsForChunk(dv, ch, sTopOrig, sTopEdit, w);
 335      }
 336    }
 337  
 338    function getMatchingOrigLine(editLine, chunks) {
 339      var editStart = 0, origStart = 0;
 340      for (var i = 0; i < chunks.length; i++) {
 341        var chunk = chunks[i];
 342        if (chunk.editTo > editLine && chunk.editFrom <= editLine) return null;
 343        if (chunk.editFrom > editLine) break;
 344        editStart = chunk.editTo;
 345        origStart = chunk.origTo;
 346      }
 347      return origStart + (editLine - editStart);
 348    }
 349  
 350    // Combines information about chunks and widgets/markers to return
 351    // an array of lines, in a single editor, that probably need to be
 352    // aligned with their counterparts in the editor next to it.
 353    function alignableFor(cm, chunks, isOrig) {
 354      var tracker = cm.state.trackAlignable
 355      var start = cm.firstLine(), trackI = 0
 356      var result = []
 357      for (var i = 0;; i++) {
 358        var chunk = chunks[i]
 359        var chunkStart = !chunk ? 1e9 : isOrig ? chunk.origFrom : chunk.editFrom
 360        for (; trackI < tracker.alignable.length; trackI += 2) {
 361          var n = tracker.alignable[trackI] + 1
 362          if (n <= start) continue
 363          if (n <= chunkStart) result.push(n)
 364          else break
 365        }
 366        if (!chunk) break
 367        result.push(start = isOrig ? chunk.origTo : chunk.editTo)
 368      }
 369      return result
 370    }
 371  
 372    // Given information about alignable lines in two editors, fill in
 373    // the result (an array of three-element arrays) to reflect the
 374    // lines that need to be aligned with each other.
 375    function mergeAlignable(result, origAlignable, chunks, setIndex) {
 376      var rI = 0, origI = 0, chunkI = 0, diff = 0
 377      outer: for (;; rI++) {
 378        var nextR = result[rI], nextO = origAlignable[origI]
 379        if (!nextR && nextO == null) break
 380  
 381        var rLine = nextR ? nextR[0] : 1e9, oLine = nextO == null ? 1e9 : nextO
 382        while (chunkI < chunks.length) {
 383          var chunk = chunks[chunkI]
 384          if (chunk.origFrom <= oLine && chunk.origTo > oLine) {
 385            origI++
 386            rI--
 387            continue outer;
 388          }
 389          if (chunk.editTo > rLine) {
 390            if (chunk.editFrom <= rLine) continue outer;
 391            break
 392          }
 393          diff += (chunk.origTo - chunk.origFrom) - (chunk.editTo - chunk.editFrom)
 394          chunkI++
 395        }
 396        if (rLine == oLine - diff) {
 397          nextR[setIndex] = oLine
 398          origI++
 399        } else if (rLine < oLine - diff) {
 400          nextR[setIndex] = rLine + diff
 401        } else {
 402          var record = [oLine - diff, null, null]
 403          record[setIndex] = oLine
 404          result.splice(rI, 0, record)
 405          origI++
 406        }
 407      }
 408    }
 409  
 410    function findAlignedLines(dv, other) {
 411      var alignable = alignableFor(dv.edit, dv.chunks, false), result = []
 412      if (other) for (var i = 0, j = 0; i < other.chunks.length; i++) {
 413        var n = other.chunks[i].editTo
 414        while (j < alignable.length && alignable[j] < n) j++
 415        if (j == alignable.length || alignable[j] != n) alignable.splice(j++, 0, n)
 416      }
 417      for (var i = 0; i < alignable.length; i++)
 418        result.push([alignable[i], null, null])
 419  
 420      mergeAlignable(result, alignableFor(dv.orig, dv.chunks, true), dv.chunks, 1)
 421      if (other)
 422        mergeAlignable(result, alignableFor(other.orig, other.chunks, true), other.chunks, 2)
 423  
 424      return result
 425    }
 426  
 427    function alignChunks(dv, force) {
 428      if (!dv.dealigned && !force) return;
 429      if (!dv.orig.curOp) return dv.orig.operation(function() {
 430        alignChunks(dv, force);
 431      });
 432  
 433      dv.dealigned = false;
 434      var other = dv.mv.left == dv ? dv.mv.right : dv.mv.left;
 435      if (other) {
 436        ensureDiff(other);
 437        other.dealigned = false;
 438      }
 439      var linesToAlign = findAlignedLines(dv, other);
 440  
 441      // Clear old aligners
 442      var aligners = dv.mv.aligners;
 443      for (var i = 0; i < aligners.length; i++)
 444        aligners[i].clear();
 445      aligners.length = 0;
 446  
 447      var cm = [dv.edit, dv.orig], scroll = [], offset = []
 448      if (other) cm.push(other.orig);
 449      for (var i = 0; i < cm.length; i++) {
 450        scroll.push(cm[i].getScrollInfo().top);
 451        offset.push(-cm[i].getScrollerElement().getBoundingClientRect().top)
 452      }
 453  
 454      if (offset[0] != offset[1] || cm.length == 3 && offset[1] != offset[2])
 455        alignLines(cm, offset, [0, 0, 0], aligners)
 456      for (var ln = 0; ln < linesToAlign.length; ln++)
 457        alignLines(cm, offset, linesToAlign[ln], aligners);
 458  
 459      for (var i = 0; i < cm.length; i++)
 460        cm[i].scrollTo(null, scroll[i]);
 461    }
 462  
 463    function alignLines(cm, cmOffset, lines, aligners) {
 464      var maxOffset = -1e8, offset = [];
 465      for (var i = 0; i < cm.length; i++) if (lines[i] != null) {
 466        var off = cm[i].heightAtLine(lines[i], "local") - cmOffset[i];
 467        offset[i] = off;
 468        maxOffset = Math.max(maxOffset, off);
 469      }
 470      for (var i = 0; i < cm.length; i++) if (lines[i] != null) {
 471        var diff = maxOffset - offset[i];
 472        if (diff > 1)
 473          aligners.push(padAbove(cm[i], lines[i], diff));
 474      }
 475    }
 476  
 477    function padAbove(cm, line, size) {
 478      var above = true;
 479      if (line > cm.lastLine()) {
 480        line--;
 481        above = false;
 482      }
 483      var elt = document.createElement("div");
 484      elt.className = "CodeMirror-merge-spacer";
 485      elt.style.height = size + "px"; elt.style.minWidth = "1px";
 486      return cm.addLineWidget(line, elt, {height: size, above: above, mergeSpacer: true, handleMouseEvents: true});
 487    }
 488  
 489    function drawConnectorsForChunk(dv, chunk, sTopOrig, sTopEdit, w) {
 490      var flip = dv.type == "left";
 491      var top = dv.orig.heightAtLine(chunk.origFrom, "local", true) - sTopOrig;
 492      if (dv.svg) {
 493        var topLpx = top;
 494        var topRpx = dv.edit.heightAtLine(chunk.editFrom, "local", true) - sTopEdit;
 495        if (flip) { var tmp = topLpx; topLpx = topRpx; topRpx = tmp; }
 496        var botLpx = dv.orig.heightAtLine(chunk.origTo, "local", true) - sTopOrig;
 497        var botRpx = dv.edit.heightAtLine(chunk.editTo, "local", true) - sTopEdit;
 498        if (flip) { var tmp = botLpx; botLpx = botRpx; botRpx = tmp; }
 499        var curveTop = " C " + w/2 + " " + topRpx + " " + w/2 + " " + topLpx + " " + (w + 2) + " " + topLpx;
 500        var curveBot = " C " + w/2 + " " + botLpx + " " + w/2 + " " + botRpx + " -1 " + botRpx;
 501        attrs(dv.svg.appendChild(document.createElementNS(svgNS, "path")),
 502              "d", "M -1 " + topRpx + curveTop + " L " + (w + 2) + " " + botLpx + curveBot + " z",
 503              "class", dv.classes.connect);
 504      }
 505      if (dv.copyButtons) {
 506        var copy = dv.copyButtons.appendChild(elt("div", dv.type == "left" ? "\u21dd" : "\u21dc",
 507                                                  "CodeMirror-merge-copy"));
 508        var editOriginals = dv.mv.options.allowEditingOriginals;
 509        copy.title = dv.edit.phrase(editOriginals ? "Push to left" : "Revert chunk");
 510        copy.chunk = chunk;
 511        copy.style.top = (chunk.origTo > chunk.origFrom ? top : dv.edit.heightAtLine(chunk.editFrom, "local") - sTopEdit) + "px";
 512        copy.setAttribute("role", "button");
 513        copy.setAttribute("tabindex", "0");
 514        copy.setAttribute("aria-label", copy.title);
 515  
 516        if (editOriginals) {
 517          var topReverse = dv.edit.heightAtLine(chunk.editFrom, "local") - sTopEdit;
 518          var copyReverse = dv.copyButtons.appendChild(elt("div", dv.type == "right" ? "\u21dd" : "\u21dc",
 519                                                           "CodeMirror-merge-copy-reverse"));
 520          copyReverse.title = "Push to right";
 521          copyReverse.chunk = {editFrom: chunk.origFrom, editTo: chunk.origTo,
 522                               origFrom: chunk.editFrom, origTo: chunk.editTo};
 523          copyReverse.style.top = topReverse + "px";
 524          dv.type == "right" ? copyReverse.style.left = "2px" : copyReverse.style.right = "2px";
 525          copyReverse.setAttribute("role", "button");
 526          copyReverse.setAttribute("tabindex", "0");
 527          copyReverse.setAttribute("aria-label", copyReverse.title);
 528        }
 529      }
 530    }
 531  
 532    function copyChunk(dv, to, from, chunk) {
 533      if (dv.diffOutOfDate) return;
 534      var origStart = chunk.origTo > from.lastLine() ? Pos(chunk.origFrom - 1) : Pos(chunk.origFrom, 0)
 535      var origEnd = Pos(chunk.origTo, 0)
 536      var editStart = chunk.editTo > to.lastLine() ? Pos(chunk.editFrom - 1) : Pos(chunk.editFrom, 0)
 537      var editEnd = Pos(chunk.editTo, 0)
 538      var handler = dv.mv.options.revertChunk
 539      if (handler)
 540        handler(dv.mv, from, origStart, origEnd, to, editStart, editEnd)
 541      else
 542        to.replaceRange(from.getRange(origStart, origEnd), editStart, editEnd)
 543    }
 544  
 545    // Merge view, containing 0, 1, or 2 diff views.
 546  
 547    var MergeView = CodeMirror.MergeView = function(node, options) {
 548      if (!(this instanceof MergeView)) return new MergeView(node, options);
 549  
 550      this.options = options;
 551      var origLeft = options.origLeft, origRight = options.origRight == null ? options.orig : options.origRight;
 552  
 553      var hasLeft = origLeft != null, hasRight = origRight != null;
 554      var panes = 1 + (hasLeft ? 1 : 0) + (hasRight ? 1 : 0);
 555      var wrap = [], left = this.left = null, right = this.right = null;
 556      var self = this;
 557  
 558      if (hasLeft) {
 559        left = this.left = new DiffView(this, "left");
 560        var leftPane = elt("div", null, "CodeMirror-merge-pane CodeMirror-merge-left");
 561        wrap.push(leftPane);
 562        wrap.push(buildGap(left));
 563      }
 564  
 565      var editPane = elt("div", null, "CodeMirror-merge-pane CodeMirror-merge-editor");
 566      wrap.push(editPane);
 567  
 568      if (hasRight) {
 569        right = this.right = new DiffView(this, "right");
 570        wrap.push(buildGap(right));
 571        var rightPane = elt("div", null, "CodeMirror-merge-pane CodeMirror-merge-right");
 572        wrap.push(rightPane);
 573      }
 574  
 575      (hasRight ? rightPane : editPane).className += " CodeMirror-merge-pane-rightmost";
 576  
 577      wrap.push(elt("div", null, null, "height: 0; clear: both;"));
 578  
 579      var wrapElt = this.wrap = node.appendChild(elt("div", wrap, "CodeMirror-merge CodeMirror-merge-" + panes + "pane"));
 580      this.edit = CodeMirror(editPane, copyObj(options));
 581  
 582      if (left) left.init(leftPane, origLeft, options);
 583      if (right) right.init(rightPane, origRight, options);
 584      if (options.collapseIdentical)
 585        this.editor().operation(function() {
 586          collapseIdenticalStretches(self, options.collapseIdentical);
 587        });
 588      if (options.connect == "align") {
 589        this.aligners = [];
 590        alignChunks(this.left || this.right, true);
 591      }
 592      if (left) left.registerEvents(right)
 593      if (right) right.registerEvents(left)
 594  
 595  
 596      var onResize = function() {
 597        if (left) makeConnections(left);
 598        if (right) makeConnections(right);
 599      };
 600      CodeMirror.on(window, "resize", onResize);
 601      var resizeInterval = setInterval(function() {
 602        for (var p = wrapElt.parentNode; p && p != document.body; p = p.parentNode) {}
 603        if (!p) { clearInterval(resizeInterval); CodeMirror.off(window, "resize", onResize); }
 604      }, 5000);
 605    };
 606  
 607    function buildGap(dv) {
 608      var lock = dv.lockButton = elt("div", null, "CodeMirror-merge-scrolllock");
 609      lock.setAttribute("role", "button");
 610      lock.setAttribute("tabindex", "0");
 611      var lockWrap = elt("div", [lock], "CodeMirror-merge-scrolllock-wrap");
 612      CodeMirror.on(lock, "click", function() { setScrollLock(dv, !dv.lockScroll); });
 613      CodeMirror.on(lock, "keyup", function(e) { e.key === "Enter" && setScrollLock(dv, !dv.lockScroll); });
 614      var gapElts = [lockWrap];
 615      if (dv.mv.options.revertButtons !== false) {
 616        dv.copyButtons = elt("div", null, "CodeMirror-merge-copybuttons-" + dv.type);
 617        function copyButtons(e) {
 618          var node = e.target || e.srcElement;
 619          if (!node.chunk) return;
 620          if (node.className == "CodeMirror-merge-copy-reverse") {
 621            copyChunk(dv, dv.orig, dv.edit, node.chunk);
 622            return;
 623          }
 624          copyChunk(dv, dv.edit, dv.orig, node.chunk);
 625        }
 626        CodeMirror.on(dv.copyButtons, "click", copyButtons);
 627        CodeMirror.on(dv.copyButtons, "keyup", function(e) { e.key === "Enter" && copyButtons(e); });
 628        gapElts.unshift(dv.copyButtons);
 629      }
 630      if (dv.mv.options.connect != "align") {
 631        var svg = document.createElementNS && document.createElementNS(svgNS, "svg");
 632        if (svg && !svg.createSVGRect) svg = null;
 633        dv.svg = svg;
 634        if (svg) gapElts.push(svg);
 635      }
 636  
 637      return dv.gap = elt("div", gapElts, "CodeMirror-merge-gap");
 638    }
 639  
 640    MergeView.prototype = {
 641      constructor: MergeView,
 642      editor: function() { return this.edit; },
 643      rightOriginal: function() { return this.right && this.right.orig; },
 644      leftOriginal: function() { return this.left && this.left.orig; },
 645      setShowDifferences: function(val) {
 646        if (this.right) this.right.setShowDifferences(val);
 647        if (this.left) this.left.setShowDifferences(val);
 648      },
 649      rightChunks: function() {
 650        if (this.right) { ensureDiff(this.right); return this.right.chunks; }
 651      },
 652      leftChunks: function() {
 653        if (this.left) { ensureDiff(this.left); return this.left.chunks; }
 654      }
 655    };
 656  
 657    function asString(obj) {
 658      if (typeof obj == "string") return obj;
 659      else return obj.getValue();
 660    }
 661  
 662    // Operations on diffs
 663    var dmp;
 664    function getDiff(a, b, ignoreWhitespace) {
 665      if (!dmp) dmp = new diff_match_patch();
 666  
 667      var diff = dmp.diff_main(a, b);
 668      // The library sometimes leaves in empty parts, which confuse the algorithm
 669      for (var i = 0; i < diff.length; ++i) {
 670        var part = diff[i];
 671        if (ignoreWhitespace ? !/[^ \t]/.test(part[1]) : !part[1]) {
 672          diff.splice(i--, 1);
 673        } else if (i && diff[i - 1][0] == part[0]) {
 674          diff.splice(i--, 1);
 675          diff[i][1] += part[1];
 676        }
 677      }
 678      return diff;
 679    }
 680  
 681    function getChunks(diff) {
 682      var chunks = [];
 683      if (!diff.length) return chunks;
 684      var startEdit = 0, startOrig = 0;
 685      var edit = Pos(0, 0), orig = Pos(0, 0);
 686      for (var i = 0; i < diff.length; ++i) {
 687        var part = diff[i], tp = part[0];
 688        if (tp == DIFF_EQUAL) {
 689          var startOff = !startOfLineClean(diff, i) || edit.line < startEdit || orig.line < startOrig ? 1 : 0;
 690          var cleanFromEdit = edit.line + startOff, cleanFromOrig = orig.line + startOff;
 691          moveOver(edit, part[1], null, orig);
 692          var endOff = endOfLineClean(diff, i) ? 1 : 0;
 693          var cleanToEdit = edit.line + endOff, cleanToOrig = orig.line + endOff;
 694          if (cleanToEdit > cleanFromEdit) {
 695            if (i) chunks.push({origFrom: startOrig, origTo: cleanFromOrig,
 696                                editFrom: startEdit, editTo: cleanFromEdit});
 697            startEdit = cleanToEdit; startOrig = cleanToOrig;
 698          }
 699        } else {
 700          moveOver(tp == DIFF_INSERT ? edit : orig, part[1]);
 701        }
 702      }
 703      if (startEdit <= edit.line || startOrig <= orig.line)
 704        chunks.push({origFrom: startOrig, origTo: orig.line + 1,
 705                     editFrom: startEdit, editTo: edit.line + 1});
 706      return chunks;
 707    }
 708  
 709    function endOfLineClean(diff, i) {
 710      if (i == diff.length - 1) return true;
 711      var next = diff[i + 1][1];
 712      if ((next.length == 1 && i < diff.length - 2) || next.charCodeAt(0) != 10) return false;
 713      if (i == diff.length - 2) return true;
 714      next = diff[i + 2][1];
 715      return (next.length > 1 || i == diff.length - 3) && next.charCodeAt(0) == 10;
 716    }
 717  
 718    function startOfLineClean(diff, i) {
 719      if (i == 0) return true;
 720      var last = diff[i - 1][1];
 721      if (last.charCodeAt(last.length - 1) != 10) return false;
 722      if (i == 1) return true;
 723      last = diff[i - 2][1];
 724      return last.charCodeAt(last.length - 1) == 10;
 725    }
 726  
 727    function chunkBoundariesAround(chunks, n, nInEdit) {
 728      var beforeE, afterE, beforeO, afterO;
 729      for (var i = 0; i < chunks.length; i++) {
 730        var chunk = chunks[i];
 731        var fromLocal = nInEdit ? chunk.editFrom : chunk.origFrom;
 732        var toLocal = nInEdit ? chunk.editTo : chunk.origTo;
 733        if (afterE == null) {
 734          if (fromLocal > n) { afterE = chunk.editFrom; afterO = chunk.origFrom; }
 735          else if (toLocal > n) { afterE = chunk.editTo; afterO = chunk.origTo; }
 736        }
 737        if (toLocal <= n) { beforeE = chunk.editTo; beforeO = chunk.origTo; }
 738        else if (fromLocal <= n) { beforeE = chunk.editFrom; beforeO = chunk.origFrom; }
 739      }
 740      return {edit: {before: beforeE, after: afterE}, orig: {before: beforeO, after: afterO}};
 741    }
 742  
 743    function collapseSingle(cm, from, to) {
 744      cm.addLineClass(from, "wrap", "CodeMirror-merge-collapsed-line");
 745      var widget = document.createElement("span");
 746      widget.className = "CodeMirror-merge-collapsed-widget";
 747      widget.title = cm.phrase("Identical text collapsed. Click to expand.");
 748      var mark = cm.markText(Pos(from, 0), Pos(to - 1), {
 749        inclusiveLeft: true,
 750        inclusiveRight: true,
 751        replacedWith: widget,
 752        clearOnEnter: true
 753      });
 754      function clear() {
 755        mark.clear();
 756        cm.removeLineClass(from, "wrap", "CodeMirror-merge-collapsed-line");
 757      }
 758      if (mark.explicitlyCleared) clear();
 759      CodeMirror.on(widget, "click", clear);
 760      mark.on("clear", clear);
 761      CodeMirror.on(widget, "click", clear);
 762      return {mark: mark, clear: clear};
 763    }
 764  
 765    function collapseStretch(size, editors) {
 766      var marks = [];
 767      function clear() {
 768        for (var i = 0; i < marks.length; i++) marks[i].clear();
 769      }
 770      for (var i = 0; i < editors.length; i++) {
 771        var editor = editors[i];
 772        var mark = collapseSingle(editor.cm, editor.line, editor.line + size);
 773        marks.push(mark);
 774        mark.mark.on("clear", clear);
 775      }
 776      return marks[0].mark;
 777    }
 778  
 779    function unclearNearChunks(dv, margin, off, clear) {
 780      for (var i = 0; i < dv.chunks.length; i++) {
 781        var chunk = dv.chunks[i];
 782        for (var l = chunk.editFrom - margin; l < chunk.editTo + margin; l++) {
 783          var pos = l + off;
 784          if (pos >= 0 && pos < clear.length) clear[pos] = false;
 785        }
 786      }
 787    }
 788  
 789    function collapseIdenticalStretches(mv, margin) {
 790      if (typeof margin != "number") margin = 2;
 791      var clear = [], edit = mv.editor(), off = edit.firstLine();
 792      for (var l = off, e = edit.lastLine(); l <= e; l++) clear.push(true);
 793      if (mv.left) unclearNearChunks(mv.left, margin, off, clear);
 794      if (mv.right) unclearNearChunks(mv.right, margin, off, clear);
 795  
 796      for (var i = 0; i < clear.length; i++) {
 797        if (clear[i]) {
 798          var line = i + off;
 799          for (var size = 1; i < clear.length - 1 && clear[i + 1]; i++, size++) {}
 800          if (size > margin) {
 801            var editors = [{line: line, cm: edit}];
 802            if (mv.left) editors.push({line: getMatchingOrigLine(line, mv.left.chunks), cm: mv.left.orig});
 803            if (mv.right) editors.push({line: getMatchingOrigLine(line, mv.right.chunks), cm: mv.right.orig});
 804            var mark = collapseStretch(size, editors);
 805            if (mv.options.onCollapse) mv.options.onCollapse(mv, line, size, mark);
 806          }
 807        }
 808      }
 809    }
 810  
 811    // General utilities
 812  
 813    function elt(tag, content, className, style) {
 814      var e = document.createElement(tag);
 815      if (className) e.className = className;
 816      if (style) e.style.cssText = style;
 817      if (typeof content == "string") e.appendChild(document.createTextNode(content));
 818      else if (content) for (var i = 0; i < content.length; ++i) e.appendChild(content[i]);
 819      return e;
 820    }
 821  
 822    function clear(node) {
 823      for (var count = node.childNodes.length; count > 0; --count)
 824        node.removeChild(node.firstChild);
 825    }
 826  
 827    function attrs(elt) {
 828      for (var i = 1; i < arguments.length; i += 2)
 829        elt.setAttribute(arguments[i], arguments[i+1]);
 830    }
 831  
 832    function copyObj(obj, target) {
 833      if (!target) target = {};
 834      for (var prop in obj) if (obj.hasOwnProperty(prop)) target[prop] = obj[prop];
 835      return target;
 836    }
 837  
 838    function moveOver(pos, str, copy, other) {
 839      var out = copy ? Pos(pos.line, pos.ch) : pos, at = 0;
 840      for (;;) {
 841        var nl = str.indexOf("\n", at);
 842        if (nl == -1) break;
 843        ++out.line;
 844        if (other) ++other.line;
 845        at = nl + 1;
 846      }
 847      out.ch = (at ? 0 : out.ch) + (str.length - at);
 848      if (other) other.ch = (at ? 0 : other.ch) + (str.length - at);
 849      return out;
 850    }
 851  
 852    // Tracks collapsed markers and line widgets, in order to be able to
 853    // accurately align the content of two editors.
 854  
 855    var F_WIDGET = 1, F_WIDGET_BELOW = 2, F_MARKER = 4
 856  
 857    function TrackAlignable(cm) {
 858      this.cm = cm
 859      this.alignable = []
 860      this.height = cm.doc.height
 861      var self = this
 862      cm.on("markerAdded", function(_, marker) {
 863        if (!marker.collapsed) return
 864        var found = marker.find(1)
 865        if (found != null) self.set(found.line, F_MARKER)
 866      })
 867      cm.on("markerCleared", function(_, marker, _min, max) {
 868        if (max != null && marker.collapsed)
 869          self.check(max, F_MARKER, self.hasMarker)
 870      })
 871      cm.on("markerChanged", this.signal.bind(this))
 872      cm.on("lineWidgetAdded", function(_, widget, lineNo) {
 873        if (widget.mergeSpacer) return
 874        if (widget.above) self.set(lineNo - 1, F_WIDGET_BELOW)
 875        else self.set(lineNo, F_WIDGET)
 876      })
 877      cm.on("lineWidgetCleared", function(_, widget, lineNo) {
 878        if (widget.mergeSpacer) return
 879        if (widget.above) self.check(lineNo - 1, F_WIDGET_BELOW, self.hasWidgetBelow)
 880        else self.check(lineNo, F_WIDGET, self.hasWidget)
 881      })
 882      cm.on("lineWidgetChanged", this.signal.bind(this))
 883      cm.on("change", function(_, change) {
 884        var start = change.from.line, nBefore = change.to.line - change.from.line
 885        var nAfter = change.text.length - 1, end = start + nAfter
 886        if (nBefore || nAfter) self.map(start, nBefore, nAfter)
 887        self.check(end, F_MARKER, self.hasMarker)
 888        if (nBefore || nAfter) self.check(change.from.line, F_MARKER, self.hasMarker)
 889      })
 890      cm.on("viewportChange", function() {
 891        if (self.cm.doc.height != self.height) self.signal()
 892      })
 893    }
 894  
 895    TrackAlignable.prototype = {
 896      signal: function() {
 897        CodeMirror.signal(this, "realign")
 898        this.height = this.cm.doc.height
 899      },
 900  
 901      set: function(n, flags) {
 902        var pos = -1
 903        for (; pos < this.alignable.length; pos += 2) {
 904          var diff = this.alignable[pos] - n
 905          if (diff == 0) {
 906            if ((this.alignable[pos + 1] & flags) == flags) return
 907            this.alignable[pos + 1] |= flags
 908            this.signal()
 909            return
 910          }
 911          if (diff > 0) break
 912        }
 913        this.signal()
 914        this.alignable.splice(pos, 0, n, flags)
 915      },
 916  
 917      find: function(n) {
 918        for (var i = 0; i < this.alignable.length; i += 2)
 919          if (this.alignable[i] == n) return i
 920        return -1
 921      },
 922  
 923      check: function(n, flag, pred) {
 924        var found = this.find(n)
 925        if (found == -1 || !(this.alignable[found + 1] & flag)) return
 926        if (!pred.call(this, n)) {
 927          this.signal()
 928          var flags = this.alignable[found + 1] & ~flag
 929          if (flags) this.alignable[found + 1] = flags
 930          else this.alignable.splice(found, 2)
 931        }
 932      },
 933  
 934      hasMarker: function(n) {
 935        var handle = this.cm.getLineHandle(n)
 936        if (handle.markedSpans) for (var i = 0; i < handle.markedSpans.length; i++)
 937          if (handle.markedSpans[i].marker.collapsed && handle.markedSpans[i].to != null)
 938            return true
 939        return false
 940      },
 941  
 942      hasWidget: function(n) {
 943        var handle = this.cm.getLineHandle(n)
 944        if (handle.widgets) for (var i = 0; i < handle.widgets.length; i++)
 945          if (!handle.widgets[i].above && !handle.widgets[i].mergeSpacer) return true
 946        return false
 947      },
 948  
 949      hasWidgetBelow: function(n) {
 950        if (n == this.cm.lastLine()) return false
 951        var handle = this.cm.getLineHandle(n + 1)
 952        if (handle.widgets) for (var i = 0; i < handle.widgets.length; i++)
 953          if (handle.widgets[i].above && !handle.widgets[i].mergeSpacer) return true
 954        return false
 955      },
 956  
 957      map: function(from, nBefore, nAfter) {
 958        var diff = nAfter - nBefore, to = from + nBefore, widgetFrom = -1, widgetTo = -1
 959        for (var i = 0; i < this.alignable.length; i += 2) {
 960          var n = this.alignable[i]
 961          if (n == from && (this.alignable[i + 1] & F_WIDGET_BELOW)) widgetFrom = i
 962          if (n == to && (this.alignable[i + 1] & F_WIDGET_BELOW)) widgetTo = i
 963          if (n <= from) continue
 964          else if (n < to) this.alignable.splice(i--, 2)
 965          else this.alignable[i] += diff
 966        }
 967        if (widgetFrom > -1) {
 968          var flags = this.alignable[widgetFrom + 1]
 969          if (flags == F_WIDGET_BELOW) this.alignable.splice(widgetFrom, 2)
 970          else this.alignable[widgetFrom + 1] = flags & ~F_WIDGET_BELOW
 971        }
 972        if (widgetTo > -1 && nAfter)
 973          this.set(from + nAfter, F_WIDGET_BELOW)
 974      }
 975    }
 976  
 977    function posMin(a, b) { return (a.line - b.line || a.ch - b.ch) < 0 ? a : b; }
 978    function posMax(a, b) { return (a.line - b.line || a.ch - b.ch) > 0 ? a : b; }
 979    function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }
 980  
 981    function findPrevDiff(chunks, start, isOrig) {
 982      for (var i = chunks.length - 1; i >= 0; i--) {
 983        var chunk = chunks[i];
 984        var to = (isOrig ? chunk.origTo : chunk.editTo) - 1;
 985        if (to < start) return to;
 986      }
 987    }
 988  
 989    function findNextDiff(chunks, start, isOrig) {
 990      for (var i = 0; i < chunks.length; i++) {
 991        var chunk = chunks[i];
 992        var from = (isOrig ? chunk.origFrom : chunk.editFrom);
 993        if (from > start) return from;
 994      }
 995    }
 996  
 997    function goNearbyDiff(cm, dir) {
 998      var found = null, views = cm.state.diffViews, line = cm.getCursor().line;
 999      if (views) for (var i = 0; i < views.length; i++) {
1000        var dv = views[i], isOrig = cm == dv.orig;
1001        ensureDiff(dv);
1002        var pos = dir < 0 ? findPrevDiff(dv.chunks, line, isOrig) : findNextDiff(dv.chunks, line, isOrig);
1003        if (pos != null && (found == null || (dir < 0 ? pos > found : pos < found)))
1004          found = pos;
1005      }
1006      if (found != null)
1007        cm.setCursor(found, 0);
1008      else
1009        return CodeMirror.Pass;
1010    }
1011  
1012    CodeMirror.commands.goNextDiff = function(cm) {
1013      return goNearbyDiff(cm, 1);
1014    };
1015    CodeMirror.commands.goPrevDiff = function(cm) {
1016      return goNearbyDiff(cm, -1);
1017    };
1018  });