platform/platform-impl/src/com/intellij/openapi/editor/impl/event/DocumentEventImpl.java

   1 /*
   2  * Copyright 2000-2009 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.openapi.editor.impl.event;
  17
  18 import com.intellij.openapi.editor.Document;
  19 import com.intellij.openapi.editor.event.DocumentEvent;
  20 import com.intellij.openapi.util.text.LineTokenizer;
  21 import com.intellij.openapi.util.text.StringUtil;
  22 import com.intellij.util.diff.Diff;
  23 import org.jetbrains.annotations.NotNull;
  24
  25 public class DocumentEventImpl extends DocumentEvent {
  26   private final int myOffset;
  27   private final CharSequence myOldString;
  28   private final int myOldLength;
  29   private final CharSequence myNewString;
  30   private final int myNewLength;
  31
  32   private boolean isOnlyOneLineChangedCalculated = false;
  33   private boolean isOnlyOneLineChanged;
  34
  35   private boolean isStartOldIndexCalculated = false;
  36   private int myStartOldIndex;
  37
  38   private final long myOldTimeStamp;
  39   private final boolean myIsWholeDocReplaced;
  40   private Diff.Change myChange;
  41
  42   private int myOptimizedLineShift = -1;
  43   private boolean myOptimizedLineShiftCalculated;
  44
  45   private int myOptimizedOldLineShift = -1;
  46   private boolean myOptimizedOldLineShiftCalculated;
  47
  48   public DocumentEventImpl(Document document, int offset, CharSequence oldString, CharSequence newString, long oldTimeStamp,
  49                            boolean wholeTextReplaced) {
  50     super(document);
  51     myOffset = offset;
  52
  53     myOldString = oldString == null ? "" : oldString;
  54     myOldLength = myOldString.length();
  55
  56     myNewString = newString == null ? "" : newString;
  57     myNewLength = myNewString.length();
  58
  59     myOldTimeStamp = oldTimeStamp;
  60
  61     if (getDocument().getTextLength() == 0) {
  62       isOnlyOneLineChangedCalculated = true;
  63       isOnlyOneLineChanged = false;
  64       myIsWholeDocReplaced = false;
  65     }
  66     else {
  67       myIsWholeDocReplaced = wholeTextReplaced;
  68     }
  69   }
  70
  71   public int getOffset() {
  72     return myOffset;
  73   }
  74
  75   public int getOldLength() {
  76     return myOldLength;
  77   }
  78
  79   public int getNewLength() {
  80     return myNewLength;
  81   }
  82
  83   public CharSequence getOldFragment() {
  84     return myOldString;
  85   }
  86
  87   public CharSequence getNewFragment() {
  88     return myNewString;
  89   }
  90
  91   @NotNull
  92   public Document getDocument() {
  93     return (Document) getSource();
  94   }
  95
  96   public int getStartOldIndex() {
  97     if(isStartOldIndexCalculated) return myStartOldIndex;
  98
  99     isStartOldIndexCalculated = true;
 100     myStartOldIndex = getDocument().getLineNumber(myOffset);
 101     return myStartOldIndex;
 102   }
 103
 104   public boolean isOnlyOneLineChanged() {
 105     if(isOnlyOneLineChangedCalculated) return isOnlyOneLineChanged;
 106
 107     isOnlyOneLineChangedCalculated = true;
 108     isOnlyOneLineChanged = true;
 109
 110     for(int i=0; i<myOldString.length(); i++) {
 111       if(myOldString.charAt(i) == '\n') {
 112         isOnlyOneLineChanged = false;
 113         break;
 114       }
 115     }
 116
 117     if(isOnlyOneLineChanged) {
 118       for(int i=0; i<myNewString.length(); i++) {
 119         if(myNewString.charAt(i) == '\n') {
 120           isOnlyOneLineChanged = false;
 121           break;
 122         }
 123       }
 124     }
 125     return isOnlyOneLineChanged;
 126   }
 127
 128   public long getOldTimeStamp() {
 129     return myOldTimeStamp;
 130   }
 131
 132   @SuppressWarnings({"HardCodedStringLiteral"})
 133   public String toString() {
 134     return "DocumentEventImpl[myOffset=" + myOffset + ", myOldLength=" + myOldLength + ", myNewLength=" + myNewLength +
 135            ", myOldString='" + myOldString + "', myNewString='" + myNewString + "']" + (isWholeTextReplaced() ? " Whole." : ".");
 136   }
 137
 138   public boolean isWholeTextReplaced() {
 139     return myIsWholeDocReplaced;
 140   }
 141
 142   public int translateLineViaDiff(int line) {
 143     if (myChange == null) buildDiff();
 144     if (myChange == null) return line;
 145
 146     Diff.Change change = myChange;
 147
 148     int newLine = line;
 149
 150     while (change != null) {
 151       if (line < change.line0) break;
 152       if (line >= change.line0 + change.deleted) {
 153         newLine += change.inserted - change.deleted;
 154       } else {
 155         int delta = Math.min(change.inserted, line - change.line0);
 156         newLine = change.line1 + delta;
 157         break;
 158       }
 159
 160       change = change.link;
 161     }
 162
 163     return newLine;
 164   }
 165
 166   public int translateLineViaDiffStrict(int line) {
 167     if (myChange == null) buildDiff();
 168     if (myChange == null) return line;
 169
 170     Diff.Change change = myChange;
 171
 172     int newLine = line;
 173
 174     while (change != null) {
 175       if (line < change.line0) break;
 176       if (line >= change.line0 + change.deleted) {
 177         newLine += change.inserted - change.deleted;
 178       } else {
 179         return -1;
 180       }
 181
 182       change = change.link;
 183     }
 184
 185     return newLine;
 186   }
 187
 188   private void buildDiff() {
 189     final String[] strings1 = LineTokenizer.tokenize(myOldString, false);
 190     final String[] strings2 = LineTokenizer.tokenize(myNewString, false);
 191
 192     //Diff diff = new Diff(strings1, strings2);
 193     //myChange = diff.diff_2(false);
 194     myChange = Diff.buildChanges(strings1, strings2);
 195   }
 196
 197   public int getOptimizedLineShift() {
 198     if (!myOptimizedLineShiftCalculated) {
 199       myOptimizedLineShiftCalculated = true;
 200
 201       if (myOldLength == 0) {
 202         int lineShift = StringUtil.countNewLines(myNewString);
 203
 204         myOptimizedLineShift = lineShift == 0 ? -1 : lineShift;
 205       }
 206     }
 207     return myOptimizedLineShift;
 208   }
 209
 210   public int getOptimizedOldLineShift() {
 211     if (!myOptimizedOldLineShiftCalculated) {
 212       myOptimizedOldLineShiftCalculated = true;
 213
 214       if (myNewLength == 0) {
 215         int lineShift = StringUtil.countNewLines(myOldString);
 216
 217         myOptimizedOldLineShift = lineShift == 0 ? -1 : lineShift;
 218       }
 219     }
 220     return myOptimizedOldLineShift;
 221   }
 222 }