f3eb5b650c993f2854b46b8cd3205aa723fbcc55
[idea/community.git] / platform / diff-impl / src / com / intellij / diff / tools / fragmented / UnifiedDiffViewer.java
1 /*
2  * Copyright 2000-2015 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.diff.tools.fragmented;
17
18 import com.intellij.diff.DiffContext;
19 import com.intellij.diff.actions.BufferedLineIterator;
20 import com.intellij.diff.actions.NavigationContextChecker;
21 import com.intellij.diff.actions.impl.OpenInEditorWithMouseAction;
22 import com.intellij.diff.actions.impl.SetEditorSettingsAction;
23 import com.intellij.diff.comparison.DiffTooBigException;
24 import com.intellij.diff.contents.DocumentContent;
25 import com.intellij.diff.fragments.LineFragment;
26 import com.intellij.diff.requests.ContentDiffRequest;
27 import com.intellij.diff.requests.DiffRequest;
28 import com.intellij.diff.tools.util.*;
29 import com.intellij.diff.tools.util.base.*;
30 import com.intellij.diff.tools.util.side.TwosideTextDiffViewer;
31 import com.intellij.diff.util.*;
32 import com.intellij.diff.util.DiffUserDataKeysEx.ScrollToPolicy;
33 import com.intellij.icons.AllIcons;
34 import com.intellij.openapi.Disposable;
35 import com.intellij.openapi.actionSystem.*;
36 import com.intellij.openapi.application.ApplicationManager;
37 import com.intellij.openapi.command.undo.UndoManager;
38 import com.intellij.openapi.diagnostic.Logger;
39 import com.intellij.openapi.diff.LineTokenizer;
40 import com.intellij.openapi.editor.*;
41 import com.intellij.openapi.editor.actionSystem.EditorActionManager;
42 import com.intellij.openapi.editor.actionSystem.ReadonlyFragmentModificationHandler;
43 import com.intellij.openapi.editor.colors.EditorColors;
44 import com.intellij.openapi.editor.event.DocumentAdapter;
45 import com.intellij.openapi.editor.event.DocumentEvent;
46 import com.intellij.openapi.editor.ex.EditorEx;
47 import com.intellij.openapi.editor.highlighter.EditorHighlighter;
48 import com.intellij.openapi.fileEditor.OpenFileDescriptor;
49 import com.intellij.openapi.fileTypes.FileType;
50 import com.intellij.openapi.progress.ProcessCanceledException;
51 import com.intellij.openapi.progress.ProgressIndicator;
52 import com.intellij.openapi.project.DumbAware;
53 import com.intellij.openapi.project.Project;
54 import com.intellij.openapi.util.Computable;
55 import com.intellij.openapi.util.Pair;
56 import com.intellij.openapi.util.UserDataHolder;
57 import com.intellij.util.Function;
58 import com.intellij.util.containers.ContainerUtil;
59 import gnu.trove.TIntFunction;
60 import org.jetbrains.annotations.*;
61
62 import javax.swing.*;
63 import java.util.*;
64
65 import static com.intellij.diff.util.DiffUtil.getLineCount;
66
67 public class UnifiedDiffViewer extends ListenerDiffViewerBase {
68   public static final Logger LOG = Logger.getInstance(UnifiedDiffViewer.class);
69
70   @NotNull protected final EditorEx myEditor;
71   @NotNull protected final Document myDocument;
72   @NotNull private final UnifiedDiffPanel myPanel;
73
74   @NotNull private final SetEditorSettingsAction myEditorSettingsAction;
75   @NotNull private final PrevNextDifferenceIterable myPrevNextDifferenceIterable;
76   @NotNull private final MyStatusPanel myStatusPanel;
77
78   @NotNull private final MyInitialScrollHelper myInitialScrollHelper = new MyInitialScrollHelper();
79   @NotNull private final MyFoldingModel myFoldingModel;
80
81   @NotNull protected Side myMasterSide = Side.RIGHT;
82
83   @Nullable private ChangedBlockData myChangedBlockData;
84
85   private final boolean[] myForceReadOnlyFlags;
86   private boolean myReadOnlyLockSet = false;
87
88   private boolean myDuringOnesideDocumentModification;
89   private boolean myDuringTwosideDocumentModification;
90
91   private boolean myStateIsOutOfDate; // whether something was changed since last rediff
92   private boolean mySuppressEditorTyping; // our state is inconsistent. No typing can be handled correctly
93
94   public UnifiedDiffViewer(@NotNull DiffContext context, @NotNull DiffRequest request) {
95     super(context, (ContentDiffRequest)request);
96
97     myPrevNextDifferenceIterable = new MyPrevNextDifferenceIterable();
98     myStatusPanel = new MyStatusPanel();
99
100     myForceReadOnlyFlags = TextDiffViewerUtil.checkForceReadOnly(myContext, myRequest);
101
102     boolean leftEditable = isEditable(Side.LEFT, false);
103     boolean rightEditable = isEditable(Side.RIGHT, false);
104     if (leftEditable && !rightEditable) myMasterSide = Side.LEFT;
105     if (!leftEditable && rightEditable) myMasterSide = Side.RIGHT;
106
107
108     myDocument = EditorFactory.getInstance().createDocument("");
109     myEditor = DiffUtil.createEditor(myDocument, myProject, true, true);
110
111     List<JComponent> titles = DiffUtil.createTextTitles(myRequest, ContainerUtil.list(myEditor, myEditor));
112     UnifiedContentPanel contentPanel = new UnifiedContentPanel(titles, myEditor);
113
114     myPanel = new UnifiedDiffPanel(myProject, contentPanel, this, myContext);
115
116     myFoldingModel = new MyFoldingModel(myEditor, this);
117
118     myEditorSettingsAction = new SetEditorSettingsAction(getTextSettings(), getEditors());
119     myEditorSettingsAction.applyDefaults();
120
121     new MyOpenInEditorWithMouseAction().register(getEditors());
122
123     TextDiffViewerUtil.checkDifferentDocuments(myRequest);
124
125     DiffUtil.registerAction(new ReplaceSelectedChangesAction(Side.LEFT, true), myPanel);
126     DiffUtil.registerAction(new AppendSelectedChangesAction(Side.LEFT, true), myPanel);
127     DiffUtil.registerAction(new ReplaceSelectedChangesAction(Side.RIGHT, true), myPanel);
128     DiffUtil.registerAction(new AppendSelectedChangesAction(Side.RIGHT, true), myPanel);
129   }
130
131   @Override
132   @CalledInAwt
133   protected void onInit() {
134     super.onInit();
135     installEditorListeners();
136     installTypingSupport();
137     myPanel.setLoadingContent(); // We need loading panel only for initial rediff()
138     myPanel.setPersistentNotifications(DiffUtil.getCustomNotifications(myContext, myRequest));
139   }
140
141   @Override
142   @CalledInAwt
143   protected void onDispose() {
144     super.onDispose();
145     EditorFactory.getInstance().releaseEditor(myEditor);
146   }
147
148   @Override
149   @CalledInAwt
150   protected void processContextHints() {
151     super.processContextHints();
152     Side side = DiffUtil.getUserData(myRequest, myContext, DiffUserDataKeys.MASTER_SIDE);
153     if (side != null) myMasterSide = side;
154
155     myInitialScrollHelper.processContext(myRequest);
156   }
157
158   @Override
159   @CalledInAwt
160   protected void updateContextHints() {
161     super.updateContextHints();
162     myInitialScrollHelper.updateContext(myRequest);
163     myFoldingModel.updateContext(myRequest, getFoldingModelSettings());
164   }
165
166   @CalledInAwt
167   protected void updateEditorCanBeTyped() {
168     myEditor.setViewer(mySuppressEditorTyping || !isEditable(myMasterSide, true));
169   }
170
171   private void installTypingSupport() {
172     if (!isEditable(myMasterSide, false)) return;
173
174     updateEditorCanBeTyped();
175     myEditor.getColorsScheme().setColor(EditorColors.READONLY_FRAGMENT_BACKGROUND_COLOR, null); // guarded blocks
176     EditorActionManager.getInstance().setReadonlyFragmentModificationHandler(myDocument, new MyReadonlyFragmentModificationHandler());
177     myDocument.putUserData(UndoManager.ORIGINAL_DOCUMENT, getDocument(myMasterSide)); // use undo of master document
178
179     myDocument.addDocumentListener(new MyOnesideDocumentListener());
180   }
181
182   @CalledInAwt
183   @NotNull
184   public List<AnAction> createToolbarActions() {
185     List<AnAction> group = new ArrayList<AnAction>();
186
187     // TODO: allow to choose myMasterSide
188     group.add(new MyIgnorePolicySettingAction());
189     group.add(new MyHighlightPolicySettingAction());
190     group.add(new MyToggleExpandByDefaultAction());
191     group.add(new MyReadOnlyLockAction());
192     group.add(myEditorSettingsAction);
193
194     group.add(Separator.getInstance());
195     group.addAll(super.createToolbarActions());
196
197     return group;
198   }
199
200   @CalledInAwt
201   @NotNull
202   public List<AnAction> createPopupActions() {
203     List<AnAction> group = new ArrayList<AnAction>();
204
205     group.add(Separator.getInstance());
206     group.add(new MyIgnorePolicySettingAction().getPopupGroup());
207     group.add(Separator.getInstance());
208     group.add(new MyHighlightPolicySettingAction().getPopupGroup());
209     group.add(Separator.getInstance());
210     group.add(new MyToggleExpandByDefaultAction());
211
212     group.add(Separator.getInstance());
213     group.addAll(super.createPopupActions());
214
215     return group;
216   }
217
218   @NotNull
219   protected List<AnAction> createEditorPopupActions() {
220     List<AnAction> group = new ArrayList<AnAction>();
221
222     group.add(new ReplaceSelectedChangesAction(Side.LEFT, false));
223     group.add(new AppendSelectedChangesAction(Side.LEFT, false));
224     group.add(new ReplaceSelectedChangesAction(Side.RIGHT, false));
225     group.add(new AppendSelectedChangesAction(Side.RIGHT, false));
226     group.add(new RevertSelectedChangesAction(Side.LEFT));
227     group.add(new RevertSelectedChangesAction(Side.RIGHT));
228
229     group.add(Separator.getInstance());
230     group.addAll(TextDiffViewerUtil.createEditorPopupActions());
231
232     return group;
233   }
234
235   @CalledInAwt
236   protected void installEditorListeners() {
237     new TextDiffViewerUtil.EditorActionsPopup(createEditorPopupActions()).install(getEditors());
238   }
239
240   //
241   // Diff
242   //
243
244   @Override
245   @CalledInAwt
246   protected void onSlowRediff() {
247     super.onSlowRediff();
248     myStatusPanel.setBusy(true);
249   }
250
251   @Override
252   @NotNull
253   protected Runnable performRediff(@NotNull final ProgressIndicator indicator) {
254     try {
255       indicator.checkCanceled();
256
257       final Document document1 = getContent1().getDocument();
258       final Document document2 = getContent2().getDocument();
259
260       final CharSequence[] texts = ApplicationManager.getApplication().runReadAction(new Computable<CharSequence[]>() {
261         @Override
262         public CharSequence[] compute() {
263           return new CharSequence[]{document1.getImmutableCharSequence(), document2.getImmutableCharSequence()};
264         }
265       });
266
267       final boolean innerFragments = getDiffConfig().innerFragments;
268       final List<LineFragment> fragments = DiffUtil.compare(texts[0], texts[1], getDiffConfig(), indicator);
269
270       final DocumentContent content1 = getContent1();
271       final DocumentContent content2 = getContent2();
272
273       indicator.checkCanceled();
274       TwosideDocumentData data = ApplicationManager.getApplication().runReadAction(new Computable<TwosideDocumentData>() {
275         @Override
276         public TwosideDocumentData compute() {
277           indicator.checkCanceled();
278           UnifiedFragmentBuilder builder = new UnifiedFragmentBuilder(fragments, document1, document2, myMasterSide);
279           builder.exec();
280
281           indicator.checkCanceled();
282
283           EditorHighlighter highlighter = buildHighlighter(myProject, content1, content2,
284                                                            texts[0], texts[1], builder.getRanges(),
285                                                            builder.getText().length());
286
287           UnifiedEditorRangeHighlighter rangeHighlighter = new UnifiedEditorRangeHighlighter(myProject, document1, document2,
288                                                                                              builder.getRanges());
289
290           return new TwosideDocumentData(builder, highlighter, rangeHighlighter);
291         }
292       });
293       UnifiedFragmentBuilder builder = data.getBuilder();
294
295       FileType fileType = content2.getContentType() == null ? content1.getContentType() : content2.getContentType();
296
297       LineNumberConvertor convertor = builder.getConvertor();
298       List<LineRange> changedLines = builder.getChangedLines();
299       boolean isEqual = builder.isEqual();
300
301       CombinedEditorData editorData = new CombinedEditorData(builder.getText(), data.getHighlighter(), data.getRangeHighlighter(), fileType,
302                                                              convertor.createConvertor1(), convertor.createConvertor2());
303
304       return apply(editorData, builder.getBlocks(), convertor, changedLines, isEqual, innerFragments);
305     }
306     catch (DiffTooBigException e) {
307       return new Runnable() {
308         @Override
309         public void run() {
310           clearDiffPresentation();
311           myPanel.setTooBigContent();
312         }
313       };
314     }
315     catch (ProcessCanceledException e) {
316       throw e;
317     }
318     catch (Throwable e) {
319       LOG.error(e);
320       return new Runnable() {
321         @Override
322         public void run() {
323           clearDiffPresentation();
324           myPanel.setErrorContent();
325         }
326       };
327     }
328   }
329
330   private void clearDiffPresentation() {
331     myPanel.resetNotifications();
332     myStatusPanel.setBusy(false);
333     destroyChangedBlockData();
334
335     myStateIsOutOfDate = false;
336     mySuppressEditorTyping = false;
337     updateEditorCanBeTyped();
338   }
339
340   @CalledInAwt
341   protected void markSuppressEditorTyping() {
342     mySuppressEditorTyping = true;
343     updateEditorCanBeTyped();
344   }
345
346   @CalledInAwt
347   protected void markStateIsOutOfDate() {
348     myStateIsOutOfDate = true;
349     if (myChangedBlockData != null) {
350       for (UnifiedDiffChange diffChange : myChangedBlockData.getDiffChanges()) {
351         diffChange.updateGutterActions();
352       }
353     }
354   }
355
356   @Nullable
357   private EditorHighlighter buildHighlighter(@Nullable Project project,
358                                              @NotNull DocumentContent content1,
359                                              @NotNull DocumentContent content2,
360                                              @NotNull CharSequence text1,
361                                              @NotNull CharSequence text2,
362                                              @NotNull List<HighlightRange> ranges,
363                                              int textLength) {
364     EditorHighlighter highlighter1 = DiffUtil.initEditorHighlighter(project, content1, text1);
365     EditorHighlighter highlighter2 = DiffUtil.initEditorHighlighter(project, content2, text2);
366
367     if (highlighter1 == null && highlighter2 == null) return null;
368     if (highlighter1 == null) highlighter1 = DiffUtil.initEmptyEditorHighlighter(text1);
369     if (highlighter2 == null) highlighter2 = DiffUtil.initEmptyEditorHighlighter(text2);
370
371     return new UnifiedEditorHighlighter(myDocument, highlighter1, highlighter2, ranges, textLength);
372   }
373
374   @NotNull
375   private Runnable apply(@NotNull final CombinedEditorData data,
376                          @NotNull final List<ChangedBlock> blocks,
377                          @NotNull final LineNumberConvertor convertor,
378                          @NotNull final List<LineRange> changedLines,
379                          final boolean isEqual, final boolean innerFragments) {
380     return new Runnable() {
381       @Override
382       public void run() {
383         myFoldingModel.updateContext(myRequest, getFoldingModelSettings());
384
385         clearDiffPresentation();
386         if (isEqual) myPanel.addNotification(DiffNotifications.EQUAL_CONTENTS);
387
388         TIntFunction separatorLines = myFoldingModel.getLineNumberConvertor();
389         myEditor.getGutterComponentEx().setLineNumberConvertor(mergeConverters(data.getLineConvertor1(), separatorLines),
390                                                                mergeConverters(data.getLineConvertor2(), separatorLines));
391
392         ApplicationManager.getApplication().runWriteAction(new Runnable() {
393           @Override
394           public void run() {
395             myDuringOnesideDocumentModification = true;
396             try {
397               myDocument.setText(data.getText());
398             }
399             finally {
400               myDuringOnesideDocumentModification = false;
401             }
402           }
403         });
404
405         if (data.getHighlighter() != null) myEditor.setHighlighter(data.getHighlighter());
406         DiffUtil.setEditorCodeStyle(myProject, myEditor, data.getFileType());
407
408         if (data.getRangeHighlighter() != null) data.getRangeHighlighter().apply(myProject, myDocument);
409
410
411         ArrayList<UnifiedDiffChange> diffChanges = new ArrayList<UnifiedDiffChange>(blocks.size());
412         for (ChangedBlock block : blocks) {
413           diffChanges.add(new UnifiedDiffChange(UnifiedDiffViewer.this, block, innerFragments));
414         }
415
416         List<RangeMarker> guarderRangeBlocks = new ArrayList<RangeMarker>();
417         if (!myEditor.isViewer()) {
418           for (ChangedBlock block : blocks) {
419             int start = myMasterSide.select(block.getStartOffset2(), block.getStartOffset1());
420             int end = myMasterSide.select(block.getEndOffset2() - 1, block.getEndOffset1() - 1);
421             if (start >= end) continue;
422             guarderRangeBlocks.add(createGuardedBlock(start, end));
423           }
424           int textLength = myDocument.getTextLength(); // there are 'fake' newline at the very end
425           guarderRangeBlocks.add(createGuardedBlock(textLength, textLength));
426         }
427
428         myChangedBlockData = new ChangedBlockData(diffChanges, guarderRangeBlocks, convertor);
429
430         myFoldingModel.install(changedLines, myRequest, getFoldingModelSettings());
431
432         myInitialScrollHelper.onRediff();
433
434         myStatusPanel.update();
435         myPanel.setGoodContent();
436       }
437     };
438   }
439
440   @NotNull
441   private RangeMarker createGuardedBlock(int start, int end) {
442     RangeMarker block = myDocument.createGuardedBlock(start, end);
443     block.setGreedyToLeft(true);
444     block.setGreedyToRight(true);
445     return block;
446   }
447
448   @Contract("!null, _ -> !null")
449   private static TIntFunction mergeConverters(@NotNull final TIntFunction convertor, @NotNull final TIntFunction separatorLines) {
450     return new TIntFunction() {
451       @Override
452       public int execute(int value) {
453         return convertor.execute(separatorLines.execute(value));
454       }
455     };
456   }
457
458   /*
459    * This convertor returns -1 if exact matching is impossible
460    */
461   @CalledInAwt
462   public int transferLineToOnesideStrict(@NotNull Side side, int line) {
463     if (myChangedBlockData == null) return -1;
464
465     LineNumberConvertor lineConvertor = myChangedBlockData.getLineNumberConvertor();
466     return side.isLeft() ? lineConvertor.convertInv1(line) : lineConvertor.convertInv2(line);
467   }
468
469   /*
470    * This convertor returns -1 if exact matching is impossible
471    */
472   @CalledInAwt
473   public int transferLineFromOnesideStrict(@NotNull Side side, int line) {
474     if (myChangedBlockData == null) return -1;
475
476     LineNumberConvertor lineConvertor = myChangedBlockData.getLineNumberConvertor();
477     return side.isLeft() ? lineConvertor.convert1(line) : lineConvertor.convert2(line);
478   }
479
480   /*
481    * This convertor returns 'good enough' position, even if exact matching is impossible
482    */
483   @CalledInAwt
484   public int transferLineToOneside(@NotNull Side side, int line) {
485     if (myChangedBlockData == null) return line;
486
487     LineNumberConvertor lineConvertor = myChangedBlockData.getLineNumberConvertor();
488     return side.isLeft() ? lineConvertor.convertApproximateInv1(line) : lineConvertor.convertApproximateInv2(line);
489   }
490
491   /*
492    * This convertor returns 'good enough' position, even if exact matching is impossible
493    */
494   @CalledInAwt
495   @NotNull
496   public Pair<int[], Side> transferLineFromOneside(int line) {
497     int[] lines = new int[2];
498
499     if (myChangedBlockData == null) {
500       lines[0] = line;
501       lines[1] = line;
502       return Pair.create(lines, myMasterSide);
503     }
504
505     LineNumberConvertor lineConvertor = myChangedBlockData.getLineNumberConvertor();
506
507     Side side = myMasterSide;
508     lines[0] = lineConvertor.convert1(line);
509     lines[1] = lineConvertor.convert2(line);
510
511     if (lines[0] == -1 && lines[1] == -1) {
512       lines[0] = lineConvertor.convertApproximate1(line);
513       lines[1] = lineConvertor.convertApproximate2(line);
514     }
515     else if (lines[0] == -1) {
516       lines[0] = lineConvertor.convertApproximate1(line);
517       side = Side.RIGHT;
518     }
519     else if (lines[1] == -1) {
520       lines[1] = lineConvertor.convertApproximate2(line);
521       side = Side.LEFT;
522     }
523
524     return Pair.create(lines, side);
525   }
526
527   @CalledInAwt
528   private void destroyChangedBlockData() {
529     if (myChangedBlockData == null) return;
530
531     for (UnifiedDiffChange change : myChangedBlockData.getDiffChanges()) {
532       change.destroyHighlighter();
533     }
534     for (RangeMarker block : myChangedBlockData.getGuardedRangeBlocks()) {
535       myDocument.removeGuardedBlock(block);
536     }
537     myChangedBlockData = null;
538
539     UnifiedEditorRangeHighlighter.erase(myProject, myDocument);
540
541     myFoldingModel.destroy();
542
543     myStatusPanel.update();
544   }
545
546   //
547   // Typing
548   //
549
550   private class MyOnesideDocumentListener extends DocumentAdapter {
551     @Override
552     public void beforeDocumentChange(DocumentEvent e) {
553       if (myDuringOnesideDocumentModification) return;
554       if (myChangedBlockData == null) {
555         LOG.warn("oneside beforeDocumentChange - myChangedBlockData == null");
556         return;
557       }
558       // TODO: modify Document guard range logic - we can handle case, when whole read-only block is modified (ex: my replacing selection).
559
560       try {
561         myDuringTwosideDocumentModification = true;
562
563         Document twosideDocument = getDocument(myMasterSide);
564
565         LineCol onesideStartPosition = LineCol.fromOffset(myDocument, e.getOffset());
566         LineCol onesideEndPosition = LineCol.fromOffset(myDocument, e.getOffset() + e.getOldLength());
567
568         int line1 = onesideStartPosition.line;
569         int line2 = onesideEndPosition.line + 1;
570         int shift = DiffUtil.countLinesShift(e);
571
572         int twosideStartLine = transferLineFromOnesideStrict(myMasterSide, onesideStartPosition.line);
573         int twosideEndLine = transferLineFromOnesideStrict(myMasterSide, onesideEndPosition.line);
574         if (twosideStartLine == -1 || twosideEndLine == -1) {
575           // this should never happen
576           logDebugInfo(e, onesideStartPosition, onesideEndPosition, twosideStartLine, twosideEndLine);
577           markSuppressEditorTyping();
578           return;
579         }
580
581         int twosideStartOffset = twosideDocument.getLineStartOffset(twosideStartLine) + onesideStartPosition.column;
582         int twosideEndOffset = twosideDocument.getLineStartOffset(twosideEndLine) + onesideEndPosition.column;
583         twosideDocument.replaceString(twosideStartOffset, twosideEndOffset, e.getNewFragment());
584
585         for (UnifiedDiffChange change : myChangedBlockData.getDiffChanges()) {
586           change.processChange(line1, line2, shift);
587         }
588
589         LineNumberConvertor lineNumberConvertor = myChangedBlockData.getLineNumberConvertor();
590         lineNumberConvertor.handleOnesideChange(line1, line2, shift, myMasterSide);
591       }
592       finally {
593         // TODO: we can avoid marking state out-of-date in some simple cases (like in SimpleDiffViewer)
594         // but this will greatly increase complexity, so let's wait if it's actually required by users
595         markStateIsOutOfDate();
596
597         myFoldingModel.onDocumentChanged(e);
598         scheduleRediff();
599
600         myDuringTwosideDocumentModification = false;
601       }
602     }
603
604     private void logDebugInfo(DocumentEvent e,
605                               LineCol onesideStartPosition, LineCol onesideEndPosition,
606                               int twosideStartLine, int twosideEndLine) {
607       StringBuilder info = new StringBuilder();
608       Document document1 = getDocument(Side.LEFT);
609       Document document2 = getDocument(Side.RIGHT);
610       info.append("==== UnifiedDiffViewer Debug Info ====");
611       info.append("myMasterSide - ").append(myMasterSide).append('\n');
612       info.append("myLeftDocument.length() - ").append(document1.getTextLength()).append('\n');
613       info.append("myRightDocument.length() - ").append(document2.getTextLength()).append('\n');
614       info.append("myDocument.length() - ").append(myDocument.getTextLength()).append('\n');
615       info.append("e.getOffset() - ").append(e.getOffset()).append('\n');
616       info.append("e.getNewLength() - ").append(e.getNewLength()).append('\n');
617       info.append("e.getOldLength() - ").append(e.getOldLength()).append('\n');
618       info.append("onesideStartPosition - ").append(onesideStartPosition).append('\n');
619       info.append("onesideEndPosition - ").append(onesideEndPosition).append('\n');
620       info.append("twosideStartLine - ").append(twosideStartLine).append('\n');
621       info.append("twosideEndLine - ").append(twosideEndLine).append('\n');
622       Pair<int[], Side> pair1 = transferLineFromOneside(onesideStartPosition.line);
623       Pair<int[], Side> pair2 = transferLineFromOneside(onesideEndPosition.line);
624       info.append("non-strict transferStartLine - ").append(pair1.first[0]).append("-").append(pair1.first[1])
625         .append(":").append(pair1.second).append('\n');
626       info.append("non-strict transferEndLine - ").append(pair2.first[0]).append("-").append(pair2.first[1])
627         .append(":").append(pair2.second).append('\n');
628       info.append("---- UnifiedDiffViewer Debug Info ----");
629
630       LOG.warn(info.toString());
631     }
632   }
633
634   @Override
635   protected void onDocumentChange(@NotNull DocumentEvent e) {
636     if (myDuringTwosideDocumentModification) return;
637
638     markStateIsOutOfDate();
639     markSuppressEditorTyping();
640
641     myFoldingModel.onDocumentChanged(e);
642     scheduleRediff();
643   }
644
645   //
646   // Modification operations
647   //
648
649   private abstract class ApplySelectedChangesActionBase extends AnAction implements DumbAware {
650     @NotNull protected final Side myModifiedSide;
651     private final boolean myShortcut;
652
653     public ApplySelectedChangesActionBase(@NotNull Side modifiedSide, boolean shortcut) {
654       myModifiedSide = modifiedSide;
655       myShortcut = shortcut;
656     }
657
658     @Override
659     public void update(@NotNull AnActionEvent e) {
660       if (myShortcut) {
661         // consume shortcut even if there are nothing to do - avoid calling some other action
662         e.getPresentation().setEnabledAndVisible(true);
663         return;
664       }
665
666       Editor editor = e.getData(CommonDataKeys.EDITOR);
667       if (editor != getEditor()) {
668         e.getPresentation().setEnabledAndVisible(false);
669         return;
670       }
671
672       if (!isEditable(myModifiedSide, true) || isStateIsOutOfDate()) {
673         e.getPresentation().setEnabledAndVisible(false);
674         return;
675       }
676
677       e.getPresentation().setVisible(true);
678       e.getPresentation().setEnabled(isSomeChangeSelected());
679     }
680
681     @Override
682     public void actionPerformed(@NotNull final AnActionEvent e) {
683       final List<UnifiedDiffChange> selectedChanges = getSelectedChanges();
684       if (selectedChanges.isEmpty()) return;
685
686       if (!isEditable(myModifiedSide, true)) return;
687       if (isStateIsOutOfDate()) return;
688
689       String title = e.getPresentation().getText() + " selected changes";
690       DiffUtil.executeWriteCommand(getDocument(myModifiedSide), e.getProject(), title, new Runnable() {
691         @Override
692         public void run() {
693           // state is invalidated during apply(), but changes are in reverse order, so they should not conflict with each other
694           apply(selectedChanges);
695           scheduleRediff();
696         }
697       });
698     }
699
700     protected boolean isSomeChangeSelected() {
701       if (myChangedBlockData == null) return false;
702       List<UnifiedDiffChange> changes = myChangedBlockData.getDiffChanges();
703       if (changes.isEmpty()) return false;
704
705       List<Caret> carets = getEditor().getCaretModel().getAllCarets();
706       if (carets.size() != 1) return true;
707       Caret caret = carets.get(0);
708       if (caret.hasSelection()) return true;
709       int line = getEditor().getDocument().getLineNumber(getEditor().getExpectedCaretOffset());
710
711       for (UnifiedDiffChange change : changes) {
712         if (DiffUtil.isSelectedByLine(line, change.getLine1(), change.getLine2())) return true;
713       }
714       return false;
715     }
716
717     @CalledWithWriteLock
718     protected abstract void apply(@NotNull List<UnifiedDiffChange> changes);
719   }
720
721   private class ReplaceSelectedChangesAction extends ApplySelectedChangesActionBase {
722     public ReplaceSelectedChangesAction(@NotNull Side focusedSide, boolean shortcut) {
723       super(focusedSide.other(), shortcut);
724
725       setShortcutSet(ActionManager.getInstance().getAction(focusedSide.select("Diff.ApplyLeftSide", "Diff.ApplyRightSide")).getShortcutSet());
726       getTemplatePresentation().setText("Replace");
727       getTemplatePresentation().setIcon(focusedSide.select(AllIcons.Diff.ArrowRight, AllIcons.Diff.Arrow));
728     }
729
730     @Override
731     protected void apply(@NotNull List<UnifiedDiffChange> changes) {
732       for (UnifiedDiffChange change : changes) {
733         replaceChange(change, myModifiedSide.other());
734       }
735     }
736   }
737
738   private class AppendSelectedChangesAction extends ApplySelectedChangesActionBase {
739     public AppendSelectedChangesAction(@NotNull Side focusedSide, boolean shortcut) {
740       super(focusedSide.other(), shortcut);
741
742       setShortcutSet(ActionManager.getInstance().getAction(focusedSide.select("Diff.AppendLeftSide", "Diff.AppendRightSide")).getShortcutSet());
743       getTemplatePresentation().setText("Insert");
744       getTemplatePresentation().setIcon(focusedSide.select(AllIcons.Diff.ArrowRightDown, AllIcons.Diff.ArrowLeftDown));
745     }
746
747     @Override
748     protected void apply(@NotNull List<UnifiedDiffChange> changes) {
749       for (UnifiedDiffChange change : changes) {
750         appendChange(change, myModifiedSide.other());
751       }
752     }
753   }
754
755   private class RevertSelectedChangesAction extends ApplySelectedChangesActionBase {
756     public RevertSelectedChangesAction(@NotNull Side focusedSide) {
757       super(focusedSide, false);
758       getTemplatePresentation().setText("Revert");
759       getTemplatePresentation().setIcon(AllIcons.Diff.Remove);
760     }
761
762     @Override
763     protected void apply(@NotNull List<UnifiedDiffChange> changes) {
764       for (UnifiedDiffChange change : changes) {
765         replaceChange(change, myModifiedSide.other());
766       }
767     }
768   }
769
770   @CalledWithWriteLock
771   public void replaceChange(@NotNull UnifiedDiffChange change, @NotNull Side sourceSide) {
772     Side outputSide = sourceSide.other();
773
774     Document document1 = getDocument(Side.LEFT);
775     Document document2 = getDocument(Side.RIGHT);
776
777     LineFragment lineFragment = change.getLineFragment();
778
779     DiffUtil.applyModification(outputSide.select(document1, document2),
780                                outputSide.getStartLine(lineFragment), outputSide.getEndLine(lineFragment),
781                                sourceSide.select(document1, document2),
782                                sourceSide.getStartLine(lineFragment), sourceSide.getEndLine(lineFragment));
783
784     // no need to mark myStateIsOutOfDate - it will be made by DocumentListener
785     // TODO: we can apply change manually, without marking state out-of-date. But we'll have to schedule rediff anyway.
786   }
787
788   @CalledWithWriteLock
789   public void appendChange(@NotNull UnifiedDiffChange change, @NotNull final Side sourceSide) {
790     Side outputSide = sourceSide.other();
791
792     Document document1 = getDocument(Side.LEFT);
793     Document document2 = getDocument(Side.RIGHT);
794
795     LineFragment lineFragment = change.getLineFragment();
796     if (sourceSide.getStartLine(lineFragment) == sourceSide.getEndLine(lineFragment)) return;
797
798     DiffUtil.applyModification(outputSide.select(document1, document2),
799                                outputSide.getEndLine(lineFragment), outputSide.getEndLine(lineFragment),
800                                sourceSide.select(document1, document2),
801                                sourceSide.getStartLine(lineFragment), sourceSide.getEndLine(lineFragment));
802   }
803
804   //
805   // Impl
806   //
807
808
809   @NotNull
810   public TextDiffSettingsHolder.TextDiffSettings getTextSettings() {
811     return TextDiffViewerUtil.getTextSettings(myContext);
812   }
813
814   @NotNull
815   public FoldingModelSupport.Settings getFoldingModelSettings() {
816     return TextDiffViewerUtil.getFoldingModelSettings(myContext);
817   }
818
819   @NotNull
820   private DiffUtil.DiffConfig getDiffConfig() {
821     return new DiffUtil.DiffConfig(getIgnorePolicy(), getHighlightPolicy());
822   }
823
824   @NotNull
825   private HighlightPolicy getHighlightPolicy() {
826     HighlightPolicy policy = getTextSettings().getHighlightPolicy();
827     if (policy == HighlightPolicy.DO_NOT_HIGHLIGHT) return HighlightPolicy.BY_LINE;
828     return policy;
829   }
830
831   @NotNull
832   private IgnorePolicy getIgnorePolicy() {
833     IgnorePolicy policy = getTextSettings().getIgnorePolicy();
834     if (policy == IgnorePolicy.IGNORE_WHITESPACES_CHUNKS) return IgnorePolicy.IGNORE_WHITESPACES;
835     return policy;
836   }
837
838   //
839   // Getters
840   //
841
842
843   @NotNull
844   public Side getMasterSide() {
845     return myMasterSide;
846   }
847
848   @NotNull
849   public EditorEx getEditor() {
850     return myEditor;
851   }
852
853   @NotNull
854   protected List<? extends EditorEx> getEditors() {
855     return Collections.singletonList(myEditor);
856   }
857
858   @NotNull
859   protected List<? extends DocumentContent> getContents() {
860     //noinspection unchecked
861     return (List<? extends DocumentContent>)(List)myRequest.getContents();
862   }
863
864   @NotNull
865   protected DocumentContent getContent(@NotNull Side side) {
866     return side.select(getContents());
867   }
868
869   @NotNull
870   protected DocumentContent getContent1() {
871     return getContent(Side.LEFT);
872   }
873
874   @NotNull
875   protected DocumentContent getContent2() {
876     return getContent(Side.RIGHT);
877   }
878
879   @CalledInAwt
880   @Nullable
881   protected List<UnifiedDiffChange> getDiffChanges() {
882     return myChangedBlockData == null ? null : myChangedBlockData.getDiffChanges();
883   }
884
885   @NotNull
886   @Override
887   public JComponent getComponent() {
888     return myPanel;
889   }
890
891   @Nullable
892   @Override
893   public JComponent getPreferredFocusedComponent() {
894     if (!myPanel.isGoodContent()) return null;
895     return myEditor.getContentComponent();
896   }
897
898   @NotNull
899   @Override
900   protected JComponent getStatusPanel() {
901     return myStatusPanel;
902   }
903
904   @CalledInAwt
905   public boolean isEditable(@NotNull Side side, boolean respectReadOnlyLock) {
906     if (myReadOnlyLockSet && respectReadOnlyLock) return false;
907     if (side.select(myForceReadOnlyFlags)) return false;
908     return DiffUtil.canMakeWritable(getDocument(side));
909   }
910
911   @NotNull
912   public Document getDocument(@NotNull Side side) {
913     return getContent(side).getDocument();
914   }
915
916   protected boolean isStateIsOutOfDate() {
917     return myStateIsOutOfDate;
918   }
919
920   //
921   // Misc
922   //
923
924   @Nullable
925   @Override
926   protected OpenFileDescriptor getOpenFileDescriptor() {
927     return getOpenFileDescriptor(myEditor.getCaretModel().getOffset());
928   }
929
930   @CalledInAwt
931   @Nullable
932   protected UnifiedDiffChange getCurrentChange() {
933     if (myChangedBlockData == null) return null;
934     int caretLine = myEditor.getCaretModel().getLogicalPosition().line;
935
936     for (UnifiedDiffChange change : myChangedBlockData.getDiffChanges()) {
937       if (DiffUtil.isSelectedByLine(caretLine, change.getLine1(), change.getLine2())) return change;
938     }
939     return null;
940   }
941
942   @NotNull
943   @CalledInAwt
944   private List<UnifiedDiffChange> getSelectedChanges() {
945     if (myChangedBlockData == null) return Collections.emptyList();
946     final BitSet lines = DiffUtil.getSelectedLines(myEditor);
947     List<UnifiedDiffChange> changes = myChangedBlockData.getDiffChanges();
948
949     List<UnifiedDiffChange> affectedChanges = new ArrayList<UnifiedDiffChange>();
950     for (int i = changes.size() - 1; i >= 0; i--) {
951       UnifiedDiffChange change = changes.get(i);
952       int line1 = change.getLine1();
953       int line2 = change.getLine2();
954
955       if (DiffUtil.isSelectedByLine(lines, line1, line2)) {
956         affectedChanges.add(change);
957       }
958     }
959     return affectedChanges;
960   }
961
962   @CalledInAwt
963   @Nullable
964   protected OpenFileDescriptor getOpenFileDescriptor(int offset) {
965     LogicalPosition position = myEditor.offsetToLogicalPosition(offset);
966     Pair<int[], Side> pair = transferLineFromOneside(position.line);
967     int offset1 = DiffUtil.getOffset(getContent1().getDocument(), pair.first[0], position.column);
968     int offset2 = DiffUtil.getOffset(getContent2().getDocument(), pair.first[1], position.column);
969
970     // TODO: issue: non-optimal GoToSource position with caret on deleted block for "Compare with local"
971     //       we should transfer using calculated diff, not jump to "somehow related" position from old content's descriptor
972
973     OpenFileDescriptor descriptor1 = getContent1().getOpenFileDescriptor(offset1);
974     OpenFileDescriptor descriptor2 = getContent2().getOpenFileDescriptor(offset2);
975     if (descriptor1 == null) return descriptor2;
976     if (descriptor2 == null) return descriptor1;
977     return pair.second.select(descriptor1, descriptor2);
978   }
979
980   public static boolean canShowRequest(@NotNull DiffContext context, @NotNull DiffRequest request) {
981     return TwosideTextDiffViewer.canShowRequest(context, request);
982   }
983
984   //
985   // Actions
986   //
987
988   private class MyPrevNextDifferenceIterable extends PrevNextDifferenceIterableBase<UnifiedDiffChange> {
989     @NotNull
990     @Override
991     protected List<UnifiedDiffChange> getChanges() {
992       return ContainerUtil.notNullize(getDiffChanges());
993     }
994
995     @NotNull
996     @Override
997     protected EditorEx getEditor() {
998       return myEditor;
999     }
1000
1001     @Override
1002     protected int getStartLine(@NotNull UnifiedDiffChange change) {
1003       return change.getLine1();
1004     }
1005
1006     @Override
1007     protected int getEndLine(@NotNull UnifiedDiffChange change) {
1008       return change.getLine2();
1009     }
1010
1011     @Override
1012     protected void scrollToChange(@NotNull UnifiedDiffChange change) {
1013       DiffUtil.scrollEditor(myEditor, change.getLine1(), true);
1014     }
1015   }
1016
1017   private class MyOpenInEditorWithMouseAction extends OpenInEditorWithMouseAction {
1018     @Override
1019     protected OpenFileDescriptor getDescriptor(@NotNull Editor editor, int line) {
1020       if (editor != myEditor) return null;
1021
1022       return getOpenFileDescriptor(myEditor.logicalPositionToOffset(new LogicalPosition(line, 0)));
1023     }
1024   }
1025
1026   private class MyToggleExpandByDefaultAction extends TextDiffViewerUtil.ToggleExpandByDefaultAction {
1027     public MyToggleExpandByDefaultAction() {
1028       super(getTextSettings());
1029     }
1030
1031     @Override
1032     protected void expandAll(boolean expand) {
1033       myFoldingModel.expandAll(expand);
1034     }
1035   }
1036
1037   private class MyHighlightPolicySettingAction extends TextDiffViewerUtil.HighlightPolicySettingAction {
1038     public MyHighlightPolicySettingAction() {
1039       super(getTextSettings());
1040     }
1041
1042     @NotNull
1043     @Override
1044     protected HighlightPolicy getCurrentSetting() {
1045       return getHighlightPolicy();
1046     }
1047
1048     @NotNull
1049     @Override
1050     protected List<HighlightPolicy> getAvailableSettings() {
1051       ArrayList<HighlightPolicy> settings = ContainerUtil.newArrayList(HighlightPolicy.values());
1052       settings.remove(HighlightPolicy.DO_NOT_HIGHLIGHT);
1053       return settings;
1054     }
1055
1056     @Override
1057     protected void onSettingsChanged() {
1058       rediff();
1059     }
1060   }
1061
1062   private class MyIgnorePolicySettingAction extends TextDiffViewerUtil.IgnorePolicySettingAction {
1063     public MyIgnorePolicySettingAction() {
1064       super(getTextSettings());
1065     }
1066
1067     @NotNull
1068     @Override
1069     protected IgnorePolicy getCurrentSetting() {
1070       return getIgnorePolicy();
1071     }
1072
1073     @NotNull
1074     @Override
1075     protected List<IgnorePolicy> getAvailableSettings() {
1076       ArrayList<IgnorePolicy> settings = ContainerUtil.newArrayList(IgnorePolicy.values());
1077       settings.remove(IgnorePolicy.IGNORE_WHITESPACES_CHUNKS);
1078       return settings;
1079     }
1080
1081     @Override
1082     protected void onSettingsChanged() {
1083       rediff();
1084     }
1085   }
1086
1087   private class MyReadOnlyLockAction extends TextDiffViewerUtil.ReadOnlyLockAction {
1088     public MyReadOnlyLockAction() {
1089       super(getContext());
1090       init();
1091     }
1092
1093     @Override
1094     protected void doApply(boolean readOnly) {
1095       myReadOnlyLockSet = readOnly;
1096       if (myChangedBlockData != null) {
1097         for (UnifiedDiffChange unifiedDiffChange : myChangedBlockData.getDiffChanges()) {
1098           unifiedDiffChange.updateGutterActions();
1099         }
1100       }
1101       updateEditorCanBeTyped();
1102     }
1103
1104     @Override
1105     protected boolean canEdit() {
1106       return !myForceReadOnlyFlags[0] && DiffUtil.canMakeWritable(getContent1().getDocument()) ||
1107              !myForceReadOnlyFlags[1] && DiffUtil.canMakeWritable(getContent2().getDocument());
1108     }
1109   }
1110
1111   //
1112   // Scroll from annotate
1113   //
1114
1115   private class AllLinesIterator implements Iterator<Pair<Integer, CharSequence>> {
1116     @NotNull private final Side mySide;
1117     @NotNull private final Document myDocument;
1118     private int myLine = 0;
1119
1120     private AllLinesIterator(@NotNull Side side) {
1121       mySide = side;
1122
1123       myDocument = getContent(mySide).getDocument();
1124     }
1125
1126     @Override
1127     public boolean hasNext() {
1128       return myLine < getLineCount(myDocument);
1129     }
1130
1131     @Override
1132     public Pair<Integer, CharSequence> next() {
1133       int offset1 = myDocument.getLineStartOffset(myLine);
1134       int offset2 = myDocument.getLineEndOffset(myLine);
1135
1136       CharSequence text = myDocument.getImmutableCharSequence().subSequence(offset1, offset2);
1137
1138       Pair<Integer, CharSequence> pair = new Pair<Integer, CharSequence>(myLine, text);
1139       myLine++;
1140
1141       return pair;
1142     }
1143
1144     @Override
1145     public void remove() {
1146       throw new UnsupportedOperationException();
1147     }
1148   }
1149
1150   private class ChangedLinesIterator extends BufferedLineIterator {
1151     @NotNull private final Side mySide;
1152     @NotNull private final List<UnifiedDiffChange> myChanges;
1153
1154     private int myIndex = 0;
1155
1156     private ChangedLinesIterator(@NotNull Side side, @NotNull List<UnifiedDiffChange> changes) {
1157       mySide = side;
1158       myChanges = changes;
1159       init();
1160     }
1161
1162     @Override
1163     public boolean hasNextBlock() {
1164       return myIndex < myChanges.size();
1165     }
1166
1167     @Override
1168     public void loadNextBlock() {
1169       LOG.assertTrue(!myStateIsOutOfDate);
1170
1171       UnifiedDiffChange change = myChanges.get(myIndex);
1172       myIndex++;
1173
1174       LineFragment lineFragment = change.getLineFragment();
1175
1176       int insertedStart = lineFragment.getStartOffset2();
1177       int insertedEnd = lineFragment.getEndOffset2();
1178       CharSequence insertedText = getContent(mySide).getDocument().getCharsSequence().subSequence(insertedStart, insertedEnd);
1179
1180       int lineNumber = lineFragment.getStartLine2();
1181
1182       LineTokenizer tokenizer = new LineTokenizer(insertedText.toString());
1183       for (String line : tokenizer.execute()) {
1184         addLine(lineNumber, line);
1185         lineNumber++;
1186       }
1187     }
1188   }
1189
1190   //
1191   // Helpers
1192   //
1193
1194   @Nullable
1195   @Override
1196   public Object getData(@NonNls String dataId) {
1197     if (DiffDataKeys.PREV_NEXT_DIFFERENCE_ITERABLE.is(dataId)) {
1198       return myPrevNextDifferenceIterable;
1199     }
1200     else if (CommonDataKeys.VIRTUAL_FILE.is(dataId)) {
1201       return DiffUtil.getVirtualFile(myRequest, myMasterSide);
1202     }
1203     else if (DiffDataKeys.CURRENT_EDITOR.is(dataId)) {
1204       return myEditor;
1205     }
1206     else if (DiffDataKeys.CURRENT_CHANGE_RANGE.is(dataId)) {
1207       UnifiedDiffChange change = getCurrentChange();
1208       if (change != null) {
1209         return new LineRange(change.getLine1(), change.getLine2());
1210       }
1211     }
1212     return super.getData(dataId);
1213   }
1214
1215   private class MyStatusPanel extends StatusPanel {
1216     @Override
1217     protected int getChangesCount() {
1218       return myChangedBlockData == null ? 0 : myChangedBlockData.getDiffChanges().size();
1219     }
1220   }
1221
1222   private static class TwosideDocumentData {
1223     @NotNull private final UnifiedFragmentBuilder myBuilder;
1224     @Nullable private final EditorHighlighter myHighlighter;
1225     @Nullable private final UnifiedEditorRangeHighlighter myRangeHighlighter;
1226
1227     public TwosideDocumentData(@NotNull UnifiedFragmentBuilder builder,
1228                                @Nullable EditorHighlighter highlighter,
1229                                @Nullable UnifiedEditorRangeHighlighter rangeHighlighter) {
1230       myBuilder = builder;
1231       myHighlighter = highlighter;
1232       myRangeHighlighter = rangeHighlighter;
1233     }
1234
1235     @NotNull
1236     public UnifiedFragmentBuilder getBuilder() {
1237       return myBuilder;
1238     }
1239
1240     @Nullable
1241     public EditorHighlighter getHighlighter() {
1242       return myHighlighter;
1243     }
1244
1245     @Nullable
1246     public UnifiedEditorRangeHighlighter getRangeHighlighter() {
1247       return myRangeHighlighter;
1248     }
1249   }
1250
1251   private static class ChangedBlockData {
1252     @NotNull private final List<UnifiedDiffChange> myDiffChanges;
1253     @NotNull private final List<RangeMarker> myGuardedRangeBlocks;
1254     @NotNull private final LineNumberConvertor myLineNumberConvertor;
1255
1256     public ChangedBlockData(@NotNull List<UnifiedDiffChange> diffChanges,
1257                             @NotNull List<RangeMarker> guarderRangeBlocks,
1258                             @NotNull LineNumberConvertor lineNumberConvertor) {
1259       myDiffChanges = diffChanges;
1260       myGuardedRangeBlocks = guarderRangeBlocks;
1261       myLineNumberConvertor = lineNumberConvertor;
1262     }
1263
1264     @NotNull
1265     public List<UnifiedDiffChange> getDiffChanges() {
1266       return myDiffChanges;
1267     }
1268
1269     @NotNull
1270     public List<RangeMarker> getGuardedRangeBlocks() {
1271       return myGuardedRangeBlocks;
1272     }
1273
1274     @NotNull
1275     public LineNumberConvertor getLineNumberConvertor() {
1276       return myLineNumberConvertor;
1277     }
1278   }
1279
1280   private static class CombinedEditorData {
1281     @NotNull private final CharSequence myText;
1282     @Nullable private final EditorHighlighter myHighlighter;
1283     @Nullable private final UnifiedEditorRangeHighlighter myRangeHighlighter;
1284     @Nullable private final FileType myFileType;
1285     @NotNull private final TIntFunction myLineConvertor1;
1286     @NotNull private final TIntFunction myLineConvertor2;
1287
1288     public CombinedEditorData(@NotNull CharSequence text,
1289                               @Nullable EditorHighlighter highlighter,
1290                               @Nullable UnifiedEditorRangeHighlighter rangeHighlighter,
1291                               @Nullable FileType fileType,
1292                               @NotNull TIntFunction convertor1,
1293                               @NotNull TIntFunction convertor2) {
1294       myText = text;
1295       myHighlighter = highlighter;
1296       myRangeHighlighter = rangeHighlighter;
1297       myFileType = fileType;
1298       myLineConvertor1 = convertor1;
1299       myLineConvertor2 = convertor2;
1300     }
1301
1302     @NotNull
1303     public CharSequence getText() {
1304       return myText;
1305     }
1306
1307     @Nullable
1308     public EditorHighlighter getHighlighter() {
1309       return myHighlighter;
1310     }
1311
1312     @Nullable
1313     public UnifiedEditorRangeHighlighter getRangeHighlighter() {
1314       return myRangeHighlighter;
1315     }
1316
1317     @Nullable
1318     public FileType getFileType() {
1319       return myFileType;
1320     }
1321
1322     @NotNull
1323     public TIntFunction getLineConvertor1() {
1324       return myLineConvertor1;
1325     }
1326
1327     @NotNull
1328     public TIntFunction getLineConvertor2() {
1329       return myLineConvertor2;
1330     }
1331   }
1332
1333   private class MyInitialScrollHelper extends InitialScrollPositionSupport.TwosideInitialScrollHelper {
1334     @NotNull
1335     @Override
1336     protected List<? extends Editor> getEditors() {
1337       return UnifiedDiffViewer.this.getEditors();
1338     }
1339
1340     @Override
1341     protected void disableSyncScroll(boolean value) {
1342     }
1343
1344     @Override
1345     public void onSlowRediff() {
1346       // Will not happen for initial rediff
1347     }
1348
1349     @Nullable
1350     @Override
1351     protected LogicalPosition[] getCaretPositions() {
1352       LogicalPosition position = myEditor.getCaretModel().getLogicalPosition();
1353       Pair<int[], Side> pair = transferLineFromOneside(position.line);
1354       LogicalPosition[] carets = new LogicalPosition[2];
1355       carets[0] = getPosition(pair.first[0], position.column);
1356       carets[1] = getPosition(pair.first[1], position.column);
1357       return carets;
1358     }
1359
1360     @Override
1361     protected boolean doScrollToPosition() {
1362       if (myCaretPosition == null) return false;
1363
1364       LogicalPosition twosidePosition = myMasterSide.selectNotNull(myCaretPosition);
1365       int onesideLine = transferLineToOneside(myMasterSide, twosidePosition.line);
1366       LogicalPosition position = new LogicalPosition(onesideLine, twosidePosition.column);
1367
1368       myEditor.getCaretModel().moveToLogicalPosition(position);
1369
1370       if (myEditorsPosition != null && myEditorsPosition.isSame(position)) {
1371         DiffUtil.scrollToPoint(myEditor, myEditorsPosition.myPoints[0], false);
1372       }
1373       else {
1374         DiffUtil.scrollToCaret(myEditor, false);
1375       }
1376       return true;
1377     }
1378
1379     @NotNull
1380     private LogicalPosition getPosition(int line, int column) {
1381       if (line == -1) return new LogicalPosition(0, 0);
1382       return new LogicalPosition(line, column);
1383     }
1384
1385     private void doScrollToLine(@NotNull Side side, @NotNull LogicalPosition position) {
1386       int onesideLine = transferLineToOneside(side, position.line);
1387       DiffUtil.scrollEditor(myEditor, onesideLine, position.column, false);
1388     }
1389
1390     @Override
1391     protected boolean doScrollToLine() {
1392       if (myScrollToLine == null) return false;
1393       doScrollToLine(myScrollToLine.first, new LogicalPosition(myScrollToLine.second, 0));
1394       return true;
1395     }
1396
1397     private boolean doScrollToChange(@NotNull ScrollToPolicy scrollToChangePolicy) {
1398       if (myChangedBlockData == null) return false;
1399       List<UnifiedDiffChange> changes = myChangedBlockData.getDiffChanges();
1400
1401       UnifiedDiffChange targetChange = scrollToChangePolicy.select(changes);
1402       if (targetChange == null) return false;
1403
1404       DiffUtil.scrollEditor(myEditor, targetChange.getLine1(), false);
1405       return true;
1406     }
1407
1408     @Override
1409     protected boolean doScrollToChange() {
1410       if (myScrollToChange == null) return false;
1411       return doScrollToChange(myScrollToChange);
1412     }
1413
1414     @Override
1415     protected boolean doScrollToFirstChange() {
1416       return doScrollToChange(ScrollToPolicy.FIRST_CHANGE);
1417     }
1418
1419     @Override
1420     protected boolean doScrollToContext() {
1421       if (myNavigationContext == null) return false;
1422       if (myChangedBlockData == null) return false;
1423
1424       ChangedLinesIterator changedLinesIterator = new ChangedLinesIterator(Side.RIGHT, myChangedBlockData.getDiffChanges());
1425       NavigationContextChecker checker = new NavigationContextChecker(changedLinesIterator, myNavigationContext);
1426       int line = checker.contextMatchCheck();
1427       if (line == -1) {
1428         // this will work for the case, when spaces changes are ignored, and corresponding fragments are not reported as changed
1429         // just try to find target line  -> +-
1430         AllLinesIterator allLinesIterator = new AllLinesIterator(Side.RIGHT);
1431         NavigationContextChecker checker2 = new NavigationContextChecker(allLinesIterator, myNavigationContext);
1432         line = checker2.contextMatchCheck();
1433       }
1434       if (line == -1) return false;
1435
1436       doScrollToLine(Side.RIGHT, new LogicalPosition(line, 0));
1437       return true;
1438     }
1439   }
1440
1441   private static class MyFoldingModel extends FoldingModelSupport {
1442     public MyFoldingModel(@NotNull EditorEx editor, @NotNull Disposable disposable) {
1443       super(new EditorEx[]{editor}, disposable);
1444     }
1445
1446     public void install(@Nullable List<LineRange> changedLines,
1447                         @NotNull UserDataHolder context,
1448                         @NotNull FoldingModelSupport.Settings settings) {
1449       Iterator<int[]> it = map(changedLines, new Function<LineRange, int[]>() {
1450         @Override
1451         public int[] fun(LineRange line) {
1452           return new int[]{
1453             line.start,
1454             line.end};
1455         }
1456       });
1457       install(it, context, settings);
1458     }
1459
1460     @NotNull
1461     public TIntFunction getLineNumberConvertor() {
1462       return getLineConvertor(0);
1463     }
1464   }
1465
1466   private static class MyReadonlyFragmentModificationHandler implements ReadonlyFragmentModificationHandler {
1467     @Override
1468     public void handle(ReadOnlyFragmentModificationException e) {
1469       // do nothing
1470     }
1471   }
1472 }