final IDocument document= firstEvent.getDocument(); int offset= firstEvent.getOffset(); int length= firstEvent.getLength(); int textLength= firstEvent.getText() == null ? 0 : firstEvent.getText().length(); final int eventOffset= event.getOffset(); final int eventLength= event.getLength(); final int eventTextLength= event.getText() == null ? 0 : event.getText().length(); return new DocumentEvent(document, offset, length, text);
@Override public void documentAboutToBeChanged(DocumentEvent event) { try { fReplacedText= event.getDocument().get(event.getOffset(), event.getLength()); fPreservedUndoModificationStamp= event.getModificationStamp(); } catch (BadLocationException x) { fReplacedText= null; } }
/** * Returns whether this position includes <code>event</code>. * * @param event the event to check. * @return <code>true</code> if this position includes <code>event</code>, * <code>false</code> otherwise */ public boolean includes(DocumentEvent event) { return includes(event.getDocument(), event.getOffset(), event.getLength()); }
@Override public void documentChanged(DocumentEvent event) { fPreservedRedoModificationStamp= event.getModificationStamp(); // record the current valid state for the top operation in case it remains the // top operation but changes state. IUndoableOperation op= fHistory.getUndoOperation(fUndoContext); boolean wasValid= false; if (op != null) wasValid= op.canUndo(); // Process the change, providing the before and after timestamps processChange(event.getOffset(), event.getOffset() + event.getLength(), event.getText(), fReplacedText, fPreservedUndoModificationStamp, fPreservedRedoModificationStamp); // now update fCurrent with the latest buffers from the document change. fCurrent.pretendCommit(); if (op == fCurrent) { // if the document change did not cause a new fCurrent to be created, then we should // notify the history that the current operation changed if its validity has changed. if (wasValid != fCurrent.isValid()) fHistory.operationChanged(op); } else { // if the change created a new fCurrent that we did not yet add to the // stack, do so if it's valid and we are not in the middle of a compound change. if (fCurrent != fLastAddedCommand && fCurrent.isValid()) { addToCommandStack(fCurrent); } } } }
@Override public void update(DocumentEvent event) { removeAffectedPositions(event.getDocument()); } }
/** * @return <code>true</code> only if the lastDamage is encloses the affected text of the given DocumentEvent. */ protected boolean isEventMatchingLastDamage(DocumentEvent e, IRegion lastDamage) { int eventStart = e.getOffset(); int eventEnd = eventStart+e.getText().length(); int damageStart = lastDamage.getOffset(); int damageEnd = damageStart+lastDamage.getLength(); boolean result = damageStart<=eventStart && damageEnd>=eventEnd; return result; }
public void documentChanged(DocumentEvent event) { // check whether the given event is the one which was remembered if (fEvent == null || event != fEvent) return; if (isPatchedEvent(event) || (event.getOffset() == 0 && event.getLength() == fRememberedLengthOfDocument)) { fLineDelimiter= null; fireTextSet(); } else { if (event.getOffset() < fRememberedLengthOfFirstLine) fLineDelimiter= null; fireTextChanged(); } }
try { String text= document.get(region.getOffset(), region.getLength()); DocumentEvent de= new DocumentEvent(document, region.getOffset(), region.getLength(), text); damage= getDamage(de, false); } catch (BadLocationException x) { document= de.getDocument(); damage= getDamage(de, true);
public int offset() { return event.getOffset(); }
/** * Notifies listener about a document change. */ private void fireDocumentChanged() { DocumentEvent ev = new DocumentEvent(); ev.fDocument = this; fireDocumentChanged(ev); }
public String text() { return event.getText(); }
public int length() { return event.getLength(); }
public void documentChanged(DocumentEvent event) { if (element.fCanBeSaved && modificationStamp == event.getModificationStamp()) { element.fCanBeSaved = false; fireElementDirtyStateChanged(element.fElement, element.fCanBeSaved); } else if (!element.fCanBeSaved) { element.fCanBeSaved = true; fireElementDirtyStateChanged(element.fElement, element.fCanBeSaved); } }
@Override public final void documentAboutToBeChanged(final DocumentEvent event) { final ComposableUndoEdit edit= new ComposableUndoEdit(); edit.setGroup(currentGroup[0]); edit.setOriginal(currentEdit[0]); edit.setUndo(createUndoEdit(document, event.getOffset(), event.getLength(), event.getText())); eventUndos.addFirst(edit); }
/** * Returns whether this position includes <code>event</code>. * * @param event the event to check. * @return <code>true</code> if this position includes <code>event</code>, * <code>false</code> otherwise */ public boolean includes(DocumentEvent event) { return includes(event.getDocument(), event.getOffset(), event.getLength()); }
@Override public void documentChanged(DocumentEvent event) { fPreservedRedoModificationStamp= event.getModificationStamp(); // record the current valid state for the top operation in case it remains the // top operation but changes state. IUndoableOperation op= fHistory.getUndoOperation(fUndoContext); boolean wasValid= false; if (op != null) wasValid= op.canUndo(); // Process the change, providing the before and after timestamps processChange(event.getOffset(), event.getOffset() + event.getLength(), event.getText(), fReplacedText, fPreservedUndoModificationStamp, fPreservedRedoModificationStamp); // now update fCurrent with the latest buffers from the document change. fCurrent.pretendCommit(); if (op == fCurrent) { // if the document change did not cause a new fCurrent to be created, then we should // notify the history that the current operation changed if its validity has changed. if (wasValid != fCurrent.isValid()) fHistory.operationChanged(op); } else { // if the change created a new fCurrent that we did not yet add to the // stack, do so if it's valid and we are not in the middle of a compound change. if (fCurrent != fLastAddedCommand && fCurrent.isValid()) { addToCommandStack(fCurrent); } } } }
@Override public void documentAboutToBeChanged(DocumentEvent e) { Assert.isTrue(e.getDocument() == fDocument); fPreviousDocumentLength= e.getDocument().getLength(); fStartOffset= -1; fEndOffset= -1; fDeleteOffset= -1; }