platform/core-impl/src/com/intellij/openapi/editor/impl/LineSet.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.openapi.editor.impl;

 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.event.DocumentEvent;
 import com.intellij.openapi.editor.ex.LineIterator;
 import com.intellij.openapi.editor.ex.util.SegmentArrayWithData;
 import com.intellij.openapi.editor.impl.event.DocumentEventImpl;
 import com.intellij.openapi.util.text.LineTokenizer;
 import com.intellij.util.text.MergingCharSequence;
 import org.jetbrains.annotations.NotNull;

 /**
  * Data structure specialized for working with document text lines, i.e. stores information about line mapping to document
  * offsets and provides convenient ways to work with that information like retrieving target line by document offset etc.
  * <p/>
  * Not thread-safe.
  */
 public class LineSet{
   private SegmentArrayWithData mySegments = new SegmentArrayWithData();
   private static final int MODIFIED_MASK = 0x4;
   private static final int SEPARATOR_MASK = 0x3;

   public int findLineIndex(int offset) {
     int lineIndex = mySegments.findSegmentIndex(offset);
     assert lineIndex >= 0;
     return lineIndex;
   }

   public LineIterator createIterator() {
     return new LineIteratorImpl(this);
   }

   public final int getLineStart(int index) {
     int lineStart = mySegments.getSegmentStart(index);
     assert lineStart >= 0;
     return lineStart;
   }

   public final int getLineEnd(int index) {
     return mySegments.getSegmentEnd(index);
   }

   final boolean isModified(int index) {
     return (mySegments.getSegmentData(index) & MODIFIED_MASK) != 0;
   }
   final void setModified(int index) {
     setSegmentModified(mySegments, index);
   }

   final int getSeparatorLength(int index) {
     return mySegments.getSegmentData(index) & SEPARATOR_MASK;
   }

   final int getLineCount() {
     return mySegments.getSegmentCount();
   }

   public void documentCreated(@NotNull Document document) {
     initSegments(document.getCharsSequence(), false);
   }

   public void changedUpdate(DocumentEvent e1) {
     DocumentEventImpl e = (DocumentEventImpl) e1;
     if (e.isOnlyOneLineChanged() && mySegments.getSegmentCount() > 0) {
       processOneLineChange(e);
     } else {
       if (mySegments.getSegmentCount() == 0 || e.getStartOldIndex() >= mySegments.getSegmentCount() ||
           e.getStartOldIndex() < 0) {
         initSegments(e.getDocument().getCharsSequence(), true);
         return;
       }

       final int optimizedLineShift = e.getOptimizedLineShift();

       if (optimizedLineShift != -1) {
         processOptimizedMultilineInsert(e, optimizedLineShift);
       } else {
         final int optimizedOldLineShift = e.getOptimizedOldLineShift();

         if (optimizedOldLineShift != -1) {
           processOptimizedMultilineDelete(e, optimizedOldLineShift);
         } else {
           processMultilineChange(e);
         }
       }
     }

     if (e.isWholeTextReplaced()) {
       clearModificationFlags();
     }
   }

   public static void setTestingMode(boolean testMode) {
     assert ApplicationManager.getApplication().isUnitTestMode();
     doTest = testMode;
   }

   private static boolean doTest = false;

   private void processOptimizedMultilineDelete(final DocumentEventImpl e, final int optimizedLineShift) {
     final int insertionPoint = e.getOffset();
     final int changedLineIndex = e.getStartOldIndex();
     final int lengthDiff = e.getOldLength();

     SegmentArrayWithData workingCopySegmentsForTesting = null;
     SegmentArrayWithData segments; //

     if (doTest) {
       segments = new SegmentArrayWithData();
       workingCopySegmentsForTesting = new SegmentArrayWithData();
       fillSegments(segments, workingCopySegmentsForTesting);
     } else {
       segments = mySegments;
     }

     final int oldSegmentStart = segments.getSegmentStart(changedLineIndex);
     final int lastChangedEnd = segments.getSegmentEnd(changedLineIndex + optimizedLineShift);
     final short lastChangedData = segments.getSegmentData(changedLineIndex + optimizedLineShift);
     final int newSegmentEnd = oldSegmentStart + (insertionPoint - oldSegmentStart) + (lastChangedEnd - insertionPoint - lengthDiff);

     segments.remove(changedLineIndex, changedLineIndex + optimizedLineShift);

     if (newSegmentEnd != 0) {
       segments.setElementAt(
         changedLineIndex,
         oldSegmentStart, newSegmentEnd,
         lastChangedData | MODIFIED_MASK
       );
     } else {
       segments.remove(changedLineIndex, changedLineIndex + 1);
     }

 // update data after lineIndex, shifting with optimizedLineShift
     final int segmentCount = segments.getSegmentCount();
     for(int i = changedLineIndex + 1; i < segmentCount; ++i) {
       segments.setElementAt(i, segments.getSegmentStart(i) - lengthDiff,
         segments.getSegmentEnd(i) - lengthDiff,
         segments.getSegmentData(i)
       );
     }

     if (doTest) {
       final SegmentArrayWithData data = mySegments;
       mySegments = segments;
       addEmptyLineAtEnd();

       doCheckResults(workingCopySegmentsForTesting, e, data, segments);
     } else {
       addEmptyLineAtEnd();
     }
   }

   private void processOptimizedMultilineInsert(final DocumentEventImpl e, final int optimizedLineShift) {
     final int insertionPoint = e.getOffset();
     final int changedLineIndex = e.getStartOldIndex();
     final int lengthDiff = e.getNewLength();
     final LineTokenizer tokenizer = new LineTokenizer(e.getNewFragment());

     SegmentArrayWithData workingCopySegmentsForTesting = null;
     SegmentArrayWithData segments; //

     if (doTest) {
       segments = new SegmentArrayWithData();
       workingCopySegmentsForTesting = new SegmentArrayWithData();
       fillSegments(segments, workingCopySegmentsForTesting);
     } else {
       segments = mySegments;
     }

     int i;

     // update data after lineIndex, shifting with optimizedLineShift
     for(i = segments.getSegmentCount() - 1; i > changedLineIndex; --i) {
       segments.setElementAt(i + optimizedLineShift, segments.getSegmentStart(i) + lengthDiff,
         segments.getSegmentEnd(i) + lengthDiff,
         segments.getSegmentData(i)
       );
     }

     final int oldSegmentEnd = segments.getSegmentEnd(changedLineIndex);
     final int oldSegmentStart = segments.getSegmentStart(changedLineIndex);
     final short oldSegmentData = segments.getSegmentData(changedLineIndex);

     final int newChangedLineEnd = insertionPoint + tokenizer.getLineSeparatorLength() + tokenizer.getOffset() + tokenizer.getLength();
     segments.setElementAt(
       changedLineIndex,
       oldSegmentStart, newChangedLineEnd,
       tokenizer.getLineSeparatorLength() | MODIFIED_MASK
     );

     tokenizer.advance();
     i = 1;
     int lastFragmentLength = 0;

     while(!tokenizer.atEnd()) {
       lastFragmentLength = tokenizer.getLineSeparatorLength() != 0 ? 0:tokenizer.getLength();
       segments.setElementAt(
         changedLineIndex + i,
         insertionPoint + tokenizer.getOffset(),
         insertionPoint + tokenizer.getOffset() + tokenizer.getLength() + tokenizer.getLineSeparatorLength(),
         tokenizer.getLineSeparatorLength() | MODIFIED_MASK
       );
       i++;
       tokenizer.advance();
     }

     segments.setElementAt(
       changedLineIndex + optimizedLineShift, insertionPoint + lengthDiff - lastFragmentLength,
       oldSegmentEnd + lengthDiff,
       oldSegmentData | MODIFIED_MASK
     );

     if (doTest) {
       final SegmentArrayWithData data = mySegments;
       mySegments = segments;
       addEmptyLineAtEnd();

       doCheckResults(workingCopySegmentsForTesting, e, data, segments);
     } else {
       addEmptyLineAtEnd();
     }
   }

   private void doCheckResults(final SegmentArrayWithData workingCopySegmentsForTesting, final DocumentEventImpl e,
                               final SegmentArrayWithData data,
                               final SegmentArrayWithData segments) {
     mySegments = workingCopySegmentsForTesting;
     processMultilineChange(e);
     mySegments = data;

     assert workingCopySegmentsForTesting.getSegmentCount() == segments.getSegmentCount();
     for(int i =0; i < segments.getSegmentCount();++i) {
       assert workingCopySegmentsForTesting.getSegmentStart(i) == segments.getSegmentStart(i);
       assert workingCopySegmentsForTesting.getSegmentEnd(i) == segments.getSegmentEnd(i);
       assert workingCopySegmentsForTesting.getSegmentData(i) == segments.getSegmentData(i);
     }

     processMultilineChange(e);
   }

   private void fillSegments(final SegmentArrayWithData segments, final SegmentArrayWithData workingCopySegmentsForTesting) {
     for(int i = mySegments.getSegmentCount() - 1; i >=0; --i) {
       segments.setElementAt(
         i,
         mySegments.getSegmentStart(i),
         mySegments.getSegmentEnd(i),
         mySegments.getSegmentData(i)
       );
       workingCopySegmentsForTesting.setElementAt(
         i,
         mySegments.getSegmentStart(i),
         mySegments.getSegmentEnd(i),
         mySegments.getSegmentData(i)
       );
     }
   }

   private void processMultilineChange(DocumentEventImpl e) {
     int offset = e.getOffset();
     CharSequence newString = e.getNewFragment();
     CharSequence chars = e.getDocument().getCharsSequence();

     int oldStartLine = e.getStartOldIndex();
     int offset1 = getLineStart(oldStartLine);
     if (offset1 != offset) {
       CharSequence prefix = chars.subSequence(offset1, offset);
       newString = new MergingCharSequence(prefix, newString);
     }

     int oldEndLine = findLineIndex(e.getOffset() + e.getOldLength());
     if (oldEndLine < 0) {
       oldEndLine = getLineCount() - 1;
     }
     int offset2 = getLineEnd(oldEndLine);
     if (offset2 != offset + e.getOldLength()) {
       final int start = offset + e.getNewLength();
       final int length = offset2 - offset - e.getOldLength();
       CharSequence postfix = chars.subSequence(start, start + length);
       newString = new MergingCharSequence(newString, postfix);
     }

     updateSegments(newString, oldStartLine, oldEndLine, offset1, e);
     // We add empty line at the end, if the last line ends by line separator.
     addEmptyLineAtEnd();
   }

   private void updateSegments(CharSequence newText, int oldStartLine, int oldEndLine, int offset1,
                                               DocumentEventImpl e) {
     int count = 0;
     LineTokenizer lineTokenizer = new LineTokenizer(newText);
     for (int index = oldStartLine; index <= oldEndLine; index++) {
       if (!lineTokenizer.atEnd()) {
         setSegmentAt(mySegments, index, lineTokenizer, offset1, true);
         lineTokenizer.advance();
       } else {
         mySegments.remove(index, oldEndLine + 1);
         break;
       }
       count++;
     }
     if (!lineTokenizer.atEnd()) {
       SegmentArrayWithData insertSegments = new SegmentArrayWithData();
       int i = 0;
       while (!lineTokenizer.atEnd()) {
         setSegmentAt(insertSegments, i, lineTokenizer, offset1, true);
         lineTokenizer.advance();
         count++;
         i++;
       }
       mySegments.insert(insertSegments, oldEndLine + 1);
     }
     int shift = e.getNewLength() - e.getOldLength();
     mySegments.shiftSegments(oldStartLine + count, shift);
   }

   private void processOneLineChange(DocumentEventImpl e) {
     // Check, if the change on the end of text
     if (e.getOffset() >= mySegments.getSegmentEnd(mySegments.getSegmentCount() - 1)) {
       mySegments.changeSegmentLength(mySegments.getSegmentCount() - 1, e.getNewLength() - e.getOldLength());
       setSegmentModified(mySegments, mySegments.getSegmentCount() - 1);
     } else {
       mySegments.changeSegmentLength(e.getStartOldIndex(), e.getNewLength() - e.getOldLength());
       setSegmentModified(mySegments, e.getStartOldIndex());
     }
   }

   public void clearModificationFlags() {
     for (int i = 0; i < mySegments.getSegmentCount(); i++) {
       mySegments.setSegmentData(i, mySegments.getSegmentData(i) & ~MODIFIED_MASK);
     }
   }

   private static void setSegmentAt(SegmentArrayWithData segmentArrayWithData, int index, LineTokenizer lineTokenizer, int offsetShift, boolean isModified) {
     int offset = lineTokenizer.getOffset() + offsetShift;
     int length = lineTokenizer.getLength();
     int separatorLength = lineTokenizer.getLineSeparatorLength();
     int separatorAndModifiedFlag = separatorLength;
     if(isModified) {
       separatorAndModifiedFlag |= MODIFIED_MASK;
     }
     segmentArrayWithData.setElementAt(index, offset, offset + length + separatorLength, separatorAndModifiedFlag);
   }

   private static void setSegmentModified(SegmentArrayWithData segments, int i) {
     segments.setSegmentData(i, segments.getSegmentData(i)|MODIFIED_MASK);
   }

   private void initSegments(CharSequence text, boolean toSetModified) {
     mySegments.removeAll();
     LineTokenizer lineTokenizer = new LineTokenizer(text);
     int i = 0;
     while(!lineTokenizer.atEnd()) {
       setSegmentAt(mySegments, i, lineTokenizer, 0, toSetModified);
       i++;
       lineTokenizer.advance();
     }
     // We add empty line at the end, if the last line ends by line separator.
     addEmptyLineAtEnd();
   }

   // Add empty line at the end, if the last line ends by line separator.
   private void addEmptyLineAtEnd() {
     int segmentCount = mySegments.getSegmentCount();
     if(segmentCount > 0 && getSeparatorLength(segmentCount-1) > 0) {
       mySegments.setElementAt(segmentCount, mySegments.getSegmentEnd(segmentCount-1),  mySegments.getSegmentEnd(segmentCount-1), 0);
       setSegmentModified(mySegments, segmentCount);
     }
   }

 }
	/*
	* Copyright 2000-2012 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.openapi.editor.impl;

	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.editor.Document;
	import com.intellij.openapi.editor.event.DocumentEvent;
	import com.intellij.openapi.editor.ex.LineIterator;
	import com.intellij.openapi.editor.ex.util.SegmentArrayWithData;
	import com.intellij.openapi.editor.impl.event.DocumentEventImpl;
	import com.intellij.openapi.util.text.LineTokenizer;
	import com.intellij.util.text.MergingCharSequence;
	import org.jetbrains.annotations.NotNull;

	/**
	* Data structure specialized for working with document text lines, i.e. stores information about line mapping to document
	* offsets and provides convenient ways to work with that information like retrieving target line by document offset etc.
	* <p/>
	* Not thread-safe.
	*/
	public class LineSet{
	private SegmentArrayWithData mySegments = new SegmentArrayWithData();
	private static final int MODIFIED_MASK = 0x4;
	private static final int SEPARATOR_MASK = 0x3;

	public int findLineIndex(int offset) {
	int lineIndex = mySegments.findSegmentIndex(offset);
	assert lineIndex >= 0;
	return lineIndex;
	}

	public LineIterator createIterator() {
	return new LineIteratorImpl(this);
	}

	public final int getLineStart(int index) {
	int lineStart = mySegments.getSegmentStart(index);
	assert lineStart >= 0;
	return lineStart;
	}

	public final int getLineEnd(int index) {
	return mySegments.getSegmentEnd(index);
	}

	final boolean isModified(int index) {
	return (mySegments.getSegmentData(index) & MODIFIED_MASK) != 0;
	}
	final void setModified(int index) {
	setSegmentModified(mySegments, index);
	}

	final int getSeparatorLength(int index) {
	return mySegments.getSegmentData(index) & SEPARATOR_MASK;
	}

	final int getLineCount() {
	return mySegments.getSegmentCount();
	}

	public void documentCreated(@NotNull Document document) {
	initSegments(document.getCharsSequence(), false);
	}

	public void changedUpdate(DocumentEvent e1) {
	DocumentEventImpl e = (DocumentEventImpl) e1;
	if (e.isOnlyOneLineChanged() && mySegments.getSegmentCount() > 0) {
	processOneLineChange(e);
	} else {
	if (mySegments.getSegmentCount() == 0 \|\| e.getStartOldIndex() >= mySegments.getSegmentCount() \|\|
	e.getStartOldIndex() < 0) {
	initSegments(e.getDocument().getCharsSequence(), true);
	return;
	}

	final int optimizedLineShift = e.getOptimizedLineShift();

	if (optimizedLineShift != -1) {
	processOptimizedMultilineInsert(e, optimizedLineShift);
	} else {
	final int optimizedOldLineShift = e.getOptimizedOldLineShift();

	if (optimizedOldLineShift != -1) {
	processOptimizedMultilineDelete(e, optimizedOldLineShift);
	} else {
	processMultilineChange(e);
	}
	}
	}

	if (e.isWholeTextReplaced()) {
	clearModificationFlags();
	}
	}

	public static void setTestingMode(boolean testMode) {
	assert ApplicationManager.getApplication().isUnitTestMode();
	doTest = testMode;
	}

	private static boolean doTest = false;

	private void processOptimizedMultilineDelete(final DocumentEventImpl e, final int optimizedLineShift) {
	final int insertionPoint = e.getOffset();
	final int changedLineIndex = e.getStartOldIndex();
	final int lengthDiff = e.getOldLength();

	SegmentArrayWithData workingCopySegmentsForTesting = null;
	SegmentArrayWithData segments; //

	if (doTest) {
	segments = new SegmentArrayWithData();
	workingCopySegmentsForTesting = new SegmentArrayWithData();
	fillSegments(segments, workingCopySegmentsForTesting);
	} else {
	segments = mySegments;
	}

	final int oldSegmentStart = segments.getSegmentStart(changedLineIndex);
	final int lastChangedEnd = segments.getSegmentEnd(changedLineIndex + optimizedLineShift);
	final short lastChangedData = segments.getSegmentData(changedLineIndex + optimizedLineShift);
	final int newSegmentEnd = oldSegmentStart + (insertionPoint - oldSegmentStart) + (lastChangedEnd - insertionPoint - lengthDiff);

	segments.remove(changedLineIndex, changedLineIndex + optimizedLineShift);

	if (newSegmentEnd != 0) {
	segments.setElementAt(
	changedLineIndex,
	oldSegmentStart, newSegmentEnd,
	lastChangedData \| MODIFIED_MASK
	);
	} else {
	segments.remove(changedLineIndex, changedLineIndex + 1);
	}

	// update data after lineIndex, shifting with optimizedLineShift
	final int segmentCount = segments.getSegmentCount();
	for(int i = changedLineIndex + 1; i < segmentCount; ++i) {
	segments.setElementAt(i, segments.getSegmentStart(i) - lengthDiff,
	segments.getSegmentEnd(i) - lengthDiff,
	segments.getSegmentData(i)
	);
	}

	if (doTest) {
	final SegmentArrayWithData data = mySegments;
	mySegments = segments;
	addEmptyLineAtEnd();

	doCheckResults(workingCopySegmentsForTesting, e, data, segments);
	} else {
	addEmptyLineAtEnd();
	}
	}

	private void processOptimizedMultilineInsert(final DocumentEventImpl e, final int optimizedLineShift) {
	final int insertionPoint = e.getOffset();
	final int changedLineIndex = e.getStartOldIndex();
	final int lengthDiff = e.getNewLength();
	final LineTokenizer tokenizer = new LineTokenizer(e.getNewFragment());

	SegmentArrayWithData workingCopySegmentsForTesting = null;
	SegmentArrayWithData segments; //

	if (doTest) {
	segments = new SegmentArrayWithData();
	workingCopySegmentsForTesting = new SegmentArrayWithData();
	fillSegments(segments, workingCopySegmentsForTesting);
	} else {
	segments = mySegments;
	}

	int i;

	// update data after lineIndex, shifting with optimizedLineShift
	for(i = segments.getSegmentCount() - 1; i > changedLineIndex; --i) {
	segments.setElementAt(i + optimizedLineShift, segments.getSegmentStart(i) + lengthDiff,
	segments.getSegmentEnd(i) + lengthDiff,
	segments.getSegmentData(i)
	);
	}

	final int oldSegmentEnd = segments.getSegmentEnd(changedLineIndex);
	final int oldSegmentStart = segments.getSegmentStart(changedLineIndex);
	final short oldSegmentData = segments.getSegmentData(changedLineIndex);

	final int newChangedLineEnd = insertionPoint + tokenizer.getLineSeparatorLength() + tokenizer.getOffset() + tokenizer.getLength();
	segments.setElementAt(
	changedLineIndex,
	oldSegmentStart, newChangedLineEnd,
	tokenizer.getLineSeparatorLength() \| MODIFIED_MASK
	);

	tokenizer.advance();
	i = 1;
	int lastFragmentLength = 0;

	while(!tokenizer.atEnd()) {
	lastFragmentLength = tokenizer.getLineSeparatorLength() != 0 ? 0:tokenizer.getLength();
	segments.setElementAt(
	changedLineIndex + i,
	insertionPoint + tokenizer.getOffset(),
	insertionPoint + tokenizer.getOffset() + tokenizer.getLength() + tokenizer.getLineSeparatorLength(),
	tokenizer.getLineSeparatorLength() \| MODIFIED_MASK
	);
	i++;
	tokenizer.advance();
	}

	segments.setElementAt(
	changedLineIndex + optimizedLineShift, insertionPoint + lengthDiff - lastFragmentLength,
	oldSegmentEnd + lengthDiff,
	oldSegmentData \| MODIFIED_MASK
	);

	if (doTest) {
	final SegmentArrayWithData data = mySegments;
	mySegments = segments;
	addEmptyLineAtEnd();

	doCheckResults(workingCopySegmentsForTesting, e, data, segments);
	} else {
	addEmptyLineAtEnd();
	}
	}

	private void doCheckResults(final SegmentArrayWithData workingCopySegmentsForTesting, final DocumentEventImpl e,
	final SegmentArrayWithData data,
	final SegmentArrayWithData segments) {
	mySegments = workingCopySegmentsForTesting;
	processMultilineChange(e);
	mySegments = data;

	assert workingCopySegmentsForTesting.getSegmentCount() == segments.getSegmentCount();
	for(int i =0; i < segments.getSegmentCount();++i) {
	assert workingCopySegmentsForTesting.getSegmentStart(i) == segments.getSegmentStart(i);
	assert workingCopySegmentsForTesting.getSegmentEnd(i) == segments.getSegmentEnd(i);
	assert workingCopySegmentsForTesting.getSegmentData(i) == segments.getSegmentData(i);
	}

	processMultilineChange(e);
	}

	private void fillSegments(final SegmentArrayWithData segments, final SegmentArrayWithData workingCopySegmentsForTesting) {
	for(int i = mySegments.getSegmentCount() - 1; i >=0; --i) {
	segments.setElementAt(
	i,
	mySegments.getSegmentStart(i),
	mySegments.getSegmentEnd(i),
	mySegments.getSegmentData(i)
	);
	workingCopySegmentsForTesting.setElementAt(
	i,
	mySegments.getSegmentStart(i),
	mySegments.getSegmentEnd(i),
	mySegments.getSegmentData(i)
	);
	}
	}

	private void processMultilineChange(DocumentEventImpl e) {
	int offset = e.getOffset();
	CharSequence newString = e.getNewFragment();
	CharSequence chars = e.getDocument().getCharsSequence();

	int oldStartLine = e.getStartOldIndex();
	int offset1 = getLineStart(oldStartLine);
	if (offset1 != offset) {
	CharSequence prefix = chars.subSequence(offset1, offset);
	newString = new MergingCharSequence(prefix, newString);
	}

	int oldEndLine = findLineIndex(e.getOffset() + e.getOldLength());
	if (oldEndLine < 0) {
	oldEndLine = getLineCount() - 1;
	}
	int offset2 = getLineEnd(oldEndLine);
	if (offset2 != offset + e.getOldLength()) {
	final int start = offset + e.getNewLength();
	final int length = offset2 - offset - e.getOldLength();
	CharSequence postfix = chars.subSequence(start, start + length);
	newString = new MergingCharSequence(newString, postfix);
	}

	updateSegments(newString, oldStartLine, oldEndLine, offset1, e);
	// We add empty line at the end, if the last line ends by line separator.
	addEmptyLineAtEnd();
	}

	private void updateSegments(CharSequence newText, int oldStartLine, int oldEndLine, int offset1,
	DocumentEventImpl e) {
	int count = 0;
	LineTokenizer lineTokenizer = new LineTokenizer(newText);
	for (int index = oldStartLine; index <= oldEndLine; index++) {
	if (!lineTokenizer.atEnd()) {
	setSegmentAt(mySegments, index, lineTokenizer, offset1, true);
	lineTokenizer.advance();
	} else {
	mySegments.remove(index, oldEndLine + 1);
	break;
	}
	count++;
	}
	if (!lineTokenizer.atEnd()) {
	SegmentArrayWithData insertSegments = new SegmentArrayWithData();
	int i = 0;
	while (!lineTokenizer.atEnd()) {
	setSegmentAt(insertSegments, i, lineTokenizer, offset1, true);
	lineTokenizer.advance();
	count++;
	i++;
	}
	mySegments.insert(insertSegments, oldEndLine + 1);
	}
	int shift = e.getNewLength() - e.getOldLength();
	mySegments.shiftSegments(oldStartLine + count, shift);
	}

	private void processOneLineChange(DocumentEventImpl e) {
	// Check, if the change on the end of text
	if (e.getOffset() >= mySegments.getSegmentEnd(mySegments.getSegmentCount() - 1)) {
	mySegments.changeSegmentLength(mySegments.getSegmentCount() - 1, e.getNewLength() - e.getOldLength());
	setSegmentModified(mySegments, mySegments.getSegmentCount() - 1);
	} else {
	mySegments.changeSegmentLength(e.getStartOldIndex(), e.getNewLength() - e.getOldLength());
	setSegmentModified(mySegments, e.getStartOldIndex());
	}
	}

	public void clearModificationFlags() {
	for (int i = 0; i < mySegments.getSegmentCount(); i++) {
	mySegments.setSegmentData(i, mySegments.getSegmentData(i) & ~MODIFIED_MASK);
	}
	}

	private static void setSegmentAt(SegmentArrayWithData segmentArrayWithData, int index, LineTokenizer lineTokenizer, int offsetShift, boolean isModified) {
	int offset = lineTokenizer.getOffset() + offsetShift;
	int length = lineTokenizer.getLength();
	int separatorLength = lineTokenizer.getLineSeparatorLength();
	int separatorAndModifiedFlag = separatorLength;
	if(isModified) {
	separatorAndModifiedFlag \|= MODIFIED_MASK;
	}
	segmentArrayWithData.setElementAt(index, offset, offset + length + separatorLength, separatorAndModifiedFlag);
	}

	private static void setSegmentModified(SegmentArrayWithData segments, int i) {
	segments.setSegmentData(i, segments.getSegmentData(i)\|MODIFIED_MASK);
	}

	private void initSegments(CharSequence text, boolean toSetModified) {
	mySegments.removeAll();
	LineTokenizer lineTokenizer = new LineTokenizer(text);
	int i = 0;
	while(!lineTokenizer.atEnd()) {
	setSegmentAt(mySegments, i, lineTokenizer, 0, toSetModified);
	i++;
	lineTokenizer.advance();
	}
	// We add empty line at the end, if the last line ends by line separator.
	addEmptyLineAtEnd();
	}

	// Add empty line at the end, if the last line ends by line separator.
	private void addEmptyLineAtEnd() {
	int segmentCount = mySegments.getSegmentCount();
	if(segmentCount > 0 && getSeparatorLength(segmentCount-1) > 0) {
	mySegments.setElementAt(segmentCount, mySegments.getSegmentEnd(segmentCount-1), mySegments.getSegmentEnd(segmentCount-1), 0);
	setSegmentModified(mySegments, segmentCount);
	}
	}

	}