Search in sources :

Example 1 with Position

use of org.eclipse.jface.text.Position in project che by eclipse.

the class MultiStateTextFileChange method getPreviewContent.

/*
	 * @see org.eclipse.ltk.core.refactoring.TextEditBasedChange#getPreviewContent(org.eclipse.ltk.core.refactoring.TextEditBasedChangeGroup[],org.eclipse.jface.text.IRegion,boolean,int,org.eclipse.core.runtime.IProgressMonitor)
	 */
public final String getPreviewContent(final TextEditBasedChangeGroup[] groups, final IRegion region, final boolean expand, final int surround, final IProgressMonitor monitor) throws CoreException {
    final Set cachedGroups = new HashSet(Arrays.asList(groups));
    final IDocument document = new Document(getCurrentDocument(monitor).get());
    // Marks the region in the document to be previewed
    final Position range = new Position(region.getOffset(), region.getLength());
    try {
        ComposableBufferChange change = null;
        final TextEditBasedChangeGroup[] changedGroups = getChangeGroups();
        LinkedList compositeUndo = new LinkedList();
        for (int index = 0; index < fChanges.size(); index++) {
            change = (ComposableBufferChange) fChanges.get(index);
            TextEdit copy = null;
            try {
                // Have to use a copy
                fCopier = new TextEditCopier(change.getEdit());
                copy = fCopier.perform();
                // Create a mapping from the copied edits to its originals
                final Map originalMap = new HashMap();
                for (final Iterator outer = change.getGroups().iterator(); outer.hasNext(); ) {
                    final ComposableBufferChangeGroup group = (ComposableBufferChangeGroup) outer.next();
                    for (final Iterator inner = group.getCachedEdits().iterator(); inner.hasNext(); ) {
                        final TextEdit originalEdit = (TextEdit) inner.next();
                        final TextEdit copiedEdit = fCopier.getCopy(originalEdit);
                        if (copiedEdit != null)
                            originalMap.put(copiedEdit, originalEdit);
                        else
                            //$NON-NLS-1$
                            RefactoringCorePlugin.logErrorMessage("Could not find a copy for the indexed text edit " + originalEdit.toString());
                    }
                }
                final ComposableBufferChangeGroup[] currentGroup = { null };
                final TextEdit[] currentEdit = { null };
                // Text edit processor which sets the change group and
                // current edit when processing
                final TextEditProcessor processor = new TextEditProcessor(document, copy, TextEdit.NONE) {

                    protected final boolean considerEdit(final TextEdit edit) {
                        final TextEdit originalEdit = (TextEdit) originalMap.get(edit);
                        if (originalEdit != null) {
                            currentEdit[0] = originalEdit;
                            boolean found = false;
                            for (int offset = 0; offset < changedGroups.length && !found; offset++) {
                                final ComposableBufferChangeGroup group = (ComposableBufferChangeGroup) changedGroups[offset];
                                if (group.containsEdit(originalEdit)) {
                                    currentGroup[0] = group;
                                    found = true;
                                }
                            }
                            if (!found)
                                currentGroup[0] = null;
                        } else if (!(edit instanceof MultiTextEdit)) {
                            //$NON-NLS-1$
                            RefactoringCorePlugin.logErrorMessage("Could not find the original of the copied text edit " + edit.toString());
                        }
                        return true;
                    }
                };
                final LinkedList eventUndos = new LinkedList();
                // Listener to record the undos on the document (offsets
                // relative to the document event)
                final IDocumentListener listener = new IDocumentListener() {

                    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);
                    }

                    public final void documentChanged(final DocumentEvent event) {
                    // Do nothing
                    }
                };
                try {
                    // Record undos in LIFO order
                    document.addDocumentListener(listener);
                    processor.performEdits();
                } finally {
                    document.removeDocumentListener(listener);
                }
                compositeUndo.addFirst(eventUndos);
            } finally {
                fCopier = null;
            }
        }
        final IPositionUpdater positionUpdater = new IPositionUpdater() {

            public final void update(final DocumentEvent event) {
                final int eventOffset = event.getOffset();
                final int eventLength = event.getLength();
                final int eventOldEndOffset = eventOffset + eventLength;
                final String eventText = event.getText();
                final int eventNewLength = eventText == null ? 0 : eventText.length();
                final int eventNewEndOffset = eventOffset + eventNewLength;
                final int deltaLength = eventNewLength - eventLength;
                try {
                    final Position[] positions = event.getDocument().getPositions(COMPOSABLE_POSITION_CATEGORY);
                    for (int index = 0; index < positions.length; index++) {
                        final Position position = positions[index];
                        if (position.isDeleted())
                            continue;
                        final int offset = position.getOffset();
                        final int length = position.getLength();
                        final int end = offset + length;
                        if (offset > eventOldEndOffset) {
                            // position comes way after change - shift
                            position.setOffset(offset + deltaLength);
                        } else if (end < eventOffset) {
                        // position comes way before change - leave
                        // alone
                        } else if (offset == eventOffset) {
                        // leave alone, since the edits are overlapping
                        } else if (offset <= eventOffset && end >= eventOldEndOffset) {
                            // event completely internal to the position
                            // -
                            // adjust length
                            position.setLength(length + deltaLength);
                        } else if (offset < eventOffset) {
                            // event extends over end of position - include
                            // the
                            // replacement text into the position
                            position.setLength(eventNewEndOffset - offset);
                        } else if (end > eventOldEndOffset) {
                            // event extends from before position into it -
                            // adjust
                            // offset and length, including the replacement
                            // text into
                            // the position
                            position.setOffset(eventOffset);
                            int deleted = eventOldEndOffset - offset;
                            position.setLength(length - deleted + eventNewLength);
                        } else {
                            // event comprises the position - keep it at the
                            // same
                            // position, but always inside the replacement
                            // text
                            int newOffset = Math.min(offset, eventNewEndOffset);
                            int newEndOffset = Math.min(end, eventNewEndOffset);
                            position.setOffset(newOffset);
                            position.setLength(newEndOffset - newOffset);
                        }
                    }
                } catch (BadPositionCategoryException exception) {
                // ignore and return
                }
            }
        };
        try {
            document.addPositionCategory(COMPOSABLE_POSITION_CATEGORY);
            document.addPositionUpdater(positionUpdater);
            // Apply undos in LIFO order to get to the original document
            // Track the undos of edits which are in change groups to be
            // previewed and insert
            // Undo edits for them (corresponding to the linearized net
            // effect on the original document)
            final LinkedList undoQueue = new LinkedList();
            for (final Iterator outer = compositeUndo.iterator(); outer.hasNext(); ) {
                for (final Iterator inner = ((List) outer.next()).iterator(); inner.hasNext(); ) {
                    final ComposableUndoEdit edit = (ComposableUndoEdit) inner.next();
                    final ReplaceEdit undo = edit.getUndo();
                    final int offset = undo.getOffset();
                    final int length = undo.getLength();
                    final String text = undo.getText();
                    ComposableEditPosition position = new ComposableEditPosition();
                    if (cachedGroups.contains(edit.getGroup())) {
                        if (text == null || text.equals("")) {
                            //$NON-NLS-1$
                            position.offset = offset;
                            if (length != 0) {
                                // Undo is a delete, create final insert
                                // edit
                                position.length = 0;
                                position.setText(edit.getOriginalText());
                            } else
                                //$NON-NLS-1$
                                RefactoringCorePlugin.logErrorMessage("Dubious undo edit found: " + undo.toString());
                        } else if (length == 0) {
                            position.offset = offset;
                            // Undo is an insert, create final delete
                            // edit
                            //$NON-NLS-1$
                            position.setText("");
                            position.length = text.length();
                        } else {
                            // Undo is a replace, create final replace edit
                            position.offset = offset;
                            position.length = length;
                            position.setText(edit.getOriginalText());
                        }
                        document.addPosition(COMPOSABLE_POSITION_CATEGORY, position);
                    }
                    position = new ComposableEditPosition();
                    position.offset = undo.getOffset();
                    position.length = undo.getLength();
                    position.setText(undo.getText());
                    undoQueue.add(position);
                }
                for (final Iterator iterator = undoQueue.iterator(); iterator.hasNext(); ) {
                    final ComposableEditPosition position = (ComposableEditPosition) iterator.next();
                    document.replace(position.offset, position.length, position.getText());
                    iterator.remove();
                }
            }
            // Use a simple non deleting position updater for the range
            final IPositionUpdater markerUpdater = new NonDeletingPositionUpdater(MARKER_POSITION_CATEGORY);
            try {
                final Position[] positions = document.getPositions(COMPOSABLE_POSITION_CATEGORY);
                document.addPositionCategory(MARKER_POSITION_CATEGORY);
                document.addPositionUpdater(markerUpdater);
                document.addPosition(MARKER_POSITION_CATEGORY, range);
                for (int index = 0; index < positions.length; index++) {
                    final ComposableEditPosition position = (ComposableEditPosition) positions[index];
                    //$NON-NLS-1$
                    document.replace(position.offset, position.length, position.getText() != null ? position.getText() : "");
                }
            } catch (BadPositionCategoryException exception) {
                RefactoringCorePlugin.log(exception);
            } finally {
                document.removePositionUpdater(markerUpdater);
                try {
                    document.removePosition(MARKER_POSITION_CATEGORY, range);
                    document.removePositionCategory(MARKER_POSITION_CATEGORY);
                } catch (BadPositionCategoryException exception) {
                // Cannot happen
                }
            }
        } catch (BadPositionCategoryException exception) {
            RefactoringCorePlugin.log(exception);
        } finally {
            document.removePositionUpdater(positionUpdater);
            try {
                document.removePositionCategory(COMPOSABLE_POSITION_CATEGORY);
            } catch (BadPositionCategoryException exception) {
                RefactoringCorePlugin.log(exception);
            }
        }
        return getContent(document, new Region(range.offset, range.length), expand, surround);
    } catch (MalformedTreeException exception) {
        RefactoringCorePlugin.log(exception);
    } catch (BadLocationException exception) {
        RefactoringCorePlugin.log(exception);
    }
    return getPreviewDocument(monitor).get();
}
Also used : Set(java.util.Set) HashSet(java.util.HashSet) HashMap(java.util.HashMap) TextEditProcessor(org.eclipse.text.edits.TextEditProcessor) Document(org.eclipse.jface.text.Document) IDocument(org.eclipse.jface.text.IDocument) TextEditCopier(org.eclipse.text.edits.TextEditCopier) NonDeletingPositionUpdater(org.eclipse.ltk.internal.core.refactoring.NonDeletingPositionUpdater) Iterator(java.util.Iterator) List(java.util.List) ArrayList(java.util.ArrayList) LinkedList(java.util.LinkedList) HashSet(java.util.HashSet) Position(org.eclipse.jface.text.Position) IDocumentListener(org.eclipse.jface.text.IDocumentListener) MalformedTreeException(org.eclipse.text.edits.MalformedTreeException) DocumentEvent(org.eclipse.jface.text.DocumentEvent) LinkedList(java.util.LinkedList) IPositionUpdater(org.eclipse.jface.text.IPositionUpdater) MultiTextEdit(org.eclipse.text.edits.MultiTextEdit) TextEdit(org.eclipse.text.edits.TextEdit) BadPositionCategoryException(org.eclipse.jface.text.BadPositionCategoryException) ReplaceEdit(org.eclipse.text.edits.ReplaceEdit) IRegion(org.eclipse.jface.text.IRegion) Region(org.eclipse.jface.text.Region) Map(java.util.Map) HashMap(java.util.HashMap) IDocument(org.eclipse.jface.text.IDocument) MultiTextEdit(org.eclipse.text.edits.MultiTextEdit) BadLocationException(org.eclipse.jface.text.BadLocationException)

Example 2 with Position

use of org.eclipse.jface.text.Position in project che by eclipse.

the class FastPartitioner method getFirstIndexStartingAfterOffset.

/**
	 * Returns the index of the first position which starts at or after the given offset.
	 *
	 * @param positions the positions in linear order
	 * @param offset the offset
	 * @return the index of the first position which starts after the offset
	 */
private int getFirstIndexStartingAfterOffset(Position[] positions, int offset) {
    int i = -1, j = positions.length;
    while (j - i > 1) {
        int k = (i + j) >> 1;
        Position p = positions[k];
        if (p.getOffset() >= offset)
            j = k;
        else
            i = k;
    }
    return j;
}
Also used : TypedPosition(org.eclipse.jface.text.TypedPosition) Position(org.eclipse.jface.text.Position)

Example 3 with Position

use of org.eclipse.jface.text.Position in project che by eclipse.

the class FastPartitioner method documentChanged2.

/**
	 * {@inheritDoc}
	 * <p>
	 * May be extended by subclasses.
	 * </p>
	 */
public IRegion documentChanged2(DocumentEvent e) {
    if (!fIsInitialized)
        return null;
    try {
        Assert.isTrue(e.getDocument() == fDocument);
        Position[] category = getPositions();
        IRegion line = fDocument.getLineInformationOfOffset(e.getOffset());
        int reparseStart = line.getOffset();
        int partitionStart = -1;
        String contentType = null;
        int newLength = e.getText() == null ? 0 : e.getText().length();
        int first = fDocument.computeIndexInCategory(fPositionCategory, reparseStart);
        if (first > 0) {
            TypedPosition partition = (TypedPosition) category[first - 1];
            if (partition.includes(reparseStart)) {
                partitionStart = partition.getOffset();
                contentType = partition.getType();
                if (e.getOffset() == partition.getOffset() + partition.getLength())
                    reparseStart = partitionStart;
                --first;
            } else if (reparseStart == e.getOffset() && reparseStart == partition.getOffset() + partition.getLength()) {
                partitionStart = partition.getOffset();
                contentType = partition.getType();
                reparseStart = partitionStart;
                --first;
            } else {
                partitionStart = partition.getOffset() + partition.getLength();
                contentType = IDocument.DEFAULT_CONTENT_TYPE;
            }
        }
        fPositionUpdater.update(e);
        for (int i = first; i < category.length; i++) {
            Position p = category[i];
            if (p.isDeleted) {
                rememberDeletedOffset(e.getOffset());
                break;
            }
        }
        clearPositionCache();
        category = getPositions();
        fScanner.setPartialRange(fDocument, reparseStart, fDocument.getLength() - reparseStart, contentType, partitionStart);
        int behindLastScannedPosition = reparseStart;
        IToken token = fScanner.nextToken();
        while (!token.isEOF()) {
            contentType = getTokenContentType(token);
            if (!isSupportedContentType(contentType)) {
                token = fScanner.nextToken();
                continue;
            }
            int start = fScanner.getTokenOffset();
            int length = fScanner.getTokenLength();
            behindLastScannedPosition = start + length;
            int lastScannedPosition = behindLastScannedPosition - 1;
            // remove all affected positions
            while (first < category.length) {
                TypedPosition p = (TypedPosition) category[first];
                if (lastScannedPosition >= p.offset + p.length || (p.overlapsWith(start, length) && (!fDocument.containsPosition(fPositionCategory, start, length) || !contentType.equals(p.getType())))) {
                    rememberRegion(p.offset, p.length);
                    fDocument.removePosition(fPositionCategory, p);
                    ++first;
                } else
                    break;
            }
            // area covered by the event, we are done
            if (fDocument.containsPosition(fPositionCategory, start, length)) {
                if (lastScannedPosition >= e.getOffset() + newLength)
                    return createRegion();
                ++first;
            } else {
                // insert the new type position
                try {
                    fDocument.addPosition(fPositionCategory, new TypedPosition(start, length, contentType));
                    rememberRegion(start, length);
                } catch (BadPositionCategoryException x) {
                } catch (BadLocationException x) {
                }
            }
            token = fScanner.nextToken();
        }
        first = fDocument.computeIndexInCategory(fPositionCategory, behindLastScannedPosition);
        clearPositionCache();
        category = getPositions();
        TypedPosition p;
        while (first < category.length) {
            p = (TypedPosition) category[first++];
            fDocument.removePosition(fPositionCategory, p);
            rememberRegion(p.offset, p.length);
        }
    } catch (BadPositionCategoryException x) {
    // should never happen on connected documents
    } catch (BadLocationException x) {
    } finally {
        clearPositionCache();
    }
    return createRegion();
}
Also used : TypedPosition(org.eclipse.jface.text.TypedPosition) Position(org.eclipse.jface.text.Position) TypedPosition(org.eclipse.jface.text.TypedPosition) BadPositionCategoryException(org.eclipse.jface.text.BadPositionCategoryException) IRegion(org.eclipse.jface.text.IRegion) BadLocationException(org.eclipse.jface.text.BadLocationException)

Example 4 with Position

use of org.eclipse.jface.text.Position in project che by eclipse.

the class FastPartitioner method computePartitioning.

/**
	 * {@inheritDoc}
	 * <p>
	 * May be replaced or extended by subclasses.
	 * </p>
	 */
public ITypedRegion[] computePartitioning(int offset, int length, boolean includeZeroLengthPartitions) {
    checkInitialization();
    List list = new ArrayList();
    try {
        int endOffset = offset + length;
        Position[] category = getPositions();
        TypedPosition previous = null, current = null;
        int start, end, gapOffset;
        Position gap = new Position(0);
        int startIndex = getFirstIndexEndingAfterOffset(category, offset);
        int endIndex = getFirstIndexStartingAfterOffset(category, endOffset);
        for (int i = startIndex; i < endIndex; i++) {
            current = (TypedPosition) category[i];
            gapOffset = (previous != null) ? previous.getOffset() + previous.getLength() : 0;
            gap.setOffset(gapOffset);
            gap.setLength(current.getOffset() - gapOffset);
            if ((includeZeroLengthPartitions && overlapsOrTouches(gap, offset, length)) || (gap.getLength() > 0 && gap.overlapsWith(offset, length))) {
                start = Math.max(offset, gapOffset);
                end = Math.min(endOffset, gap.getOffset() + gap.getLength());
                list.add(new TypedRegion(start, end - start, IDocument.DEFAULT_CONTENT_TYPE));
            }
            if (current.overlapsWith(offset, length)) {
                start = Math.max(offset, current.getOffset());
                end = Math.min(endOffset, current.getOffset() + current.getLength());
                list.add(new TypedRegion(start, end - start, current.getType()));
            }
            previous = current;
        }
        if (previous != null) {
            gapOffset = previous.getOffset() + previous.getLength();
            gap.setOffset(gapOffset);
            gap.setLength(fDocument.getLength() - gapOffset);
            if ((includeZeroLengthPartitions && overlapsOrTouches(gap, offset, length)) || (gap.getLength() > 0 && gap.overlapsWith(offset, length))) {
                start = Math.max(offset, gapOffset);
                end = Math.min(endOffset, fDocument.getLength());
                list.add(new TypedRegion(start, end - start, IDocument.DEFAULT_CONTENT_TYPE));
            }
        }
        if (list.isEmpty())
            list.add(new TypedRegion(offset, length, IDocument.DEFAULT_CONTENT_TYPE));
    } catch (BadPositionCategoryException ex) {
        // Make sure we clear the cache
        clearPositionCache();
    } catch (RuntimeException ex) {
        // Make sure we clear the cache
        clearPositionCache();
        throw ex;
    }
    TypedRegion[] result = new TypedRegion[list.size()];
    list.toArray(result);
    return result;
}
Also used : TypedPosition(org.eclipse.jface.text.TypedPosition) Position(org.eclipse.jface.text.Position) TypedPosition(org.eclipse.jface.text.TypedPosition) ArrayList(java.util.ArrayList) BadPositionCategoryException(org.eclipse.jface.text.BadPositionCategoryException) ArrayList(java.util.ArrayList) List(java.util.List) ITypedRegion(org.eclipse.jface.text.ITypedRegion) TypedRegion(org.eclipse.jface.text.TypedRegion)

Example 5 with Position

use of org.eclipse.jface.text.Position in project che by eclipse.

the class FastPartitioner method getPartition.

/**
	 * {@inheritDoc}
	 * <p>
	 * May be replaced or extended by subclasses.
	 * </p>
	 */
public ITypedRegion getPartition(int offset) {
    checkInitialization();
    try {
        Position[] category = getPositions();
        if (category == null || category.length == 0)
            return new TypedRegion(0, fDocument.getLength(), IDocument.DEFAULT_CONTENT_TYPE);
        int index = fDocument.computeIndexInCategory(fPositionCategory, offset);
        if (index < category.length) {
            TypedPosition next = (TypedPosition) category[index];
            if (offset == next.offset)
                return new TypedRegion(next.getOffset(), next.getLength(), next.getType());
            if (index == 0)
                return new TypedRegion(0, next.offset, IDocument.DEFAULT_CONTENT_TYPE);
            TypedPosition previous = (TypedPosition) category[index - 1];
            if (previous.includes(offset))
                return new TypedRegion(previous.getOffset(), previous.getLength(), previous.getType());
            int endOffset = previous.getOffset() + previous.getLength();
            return new TypedRegion(endOffset, next.getOffset() - endOffset, IDocument.DEFAULT_CONTENT_TYPE);
        }
        TypedPosition previous = (TypedPosition) category[category.length - 1];
        if (previous.includes(offset))
            return new TypedRegion(previous.getOffset(), previous.getLength(), previous.getType());
        int endOffset = previous.getOffset() + previous.getLength();
        return new TypedRegion(endOffset, fDocument.getLength() - endOffset, IDocument.DEFAULT_CONTENT_TYPE);
    } catch (BadPositionCategoryException x) {
    } catch (BadLocationException x) {
    }
    return new TypedRegion(0, fDocument.getLength(), IDocument.DEFAULT_CONTENT_TYPE);
}
Also used : TypedPosition(org.eclipse.jface.text.TypedPosition) Position(org.eclipse.jface.text.Position) TypedPosition(org.eclipse.jface.text.TypedPosition) BadPositionCategoryException(org.eclipse.jface.text.BadPositionCategoryException) ITypedRegion(org.eclipse.jface.text.ITypedRegion) TypedRegion(org.eclipse.jface.text.TypedRegion) BadLocationException(org.eclipse.jface.text.BadLocationException)

Aggregations

Position (org.eclipse.jface.text.Position)421 BadLocationException (org.eclipse.jface.text.BadLocationException)145 Annotation (org.eclipse.jface.text.source.Annotation)110 IDocument (org.eclipse.jface.text.IDocument)80 ArrayList (java.util.ArrayList)75 IAnnotationModel (org.eclipse.jface.text.source.IAnnotationModel)57 IRegion (org.eclipse.jface.text.IRegion)55 Test (org.junit.Test)54 HashMap (java.util.HashMap)49 BadPositionCategoryException (org.eclipse.jface.text.BadPositionCategoryException)46 Point (org.eclipse.swt.graphics.Point)40 List (java.util.List)39 Iterator (java.util.Iterator)31 TypedPosition (org.eclipse.jface.text.TypedPosition)31 Region (org.eclipse.jface.text.Region)27 IFile (org.eclipse.core.resources.IFile)22 IAnnotationModelExtension (org.eclipse.jface.text.source.IAnnotationModelExtension)21 ProjectionAnnotation (org.eclipse.jface.text.source.projection.ProjectionAnnotation)21 Map (java.util.Map)15 CoreException (org.eclipse.core.runtime.CoreException)15