Java Code Examples for org.eclipse.jface.text.ITypedRegion#getOffset()

@Override
protected void runInternal(ITextSelection selection, IDocumentExtension3 docExtension, Edit.EditFactory factory) throws BadLocationException, BadPartitioningException {
	int selectionOffset= selection.getOffset();
	int selectionEndOffset= selectionOffset + selection.getLength();
	List<Edit> edits= new LinkedList<Edit>();
	ITypedRegion partition= docExtension.getPartition(IJavaPartitions.JAVA_PARTITIONING, selectionOffset, false);

	handleFirstPartition(partition, edits, factory, selectionOffset);

	while (partition.getOffset() + partition.getLength() < selectionEndOffset) {
		partition= handleInteriorPartition(partition, edits, factory, docExtension);
	}

	handleLastPartition(partition, edits, factory, selectionEndOffset);

	executeEdits(edits);
}
 

/**
 * Returns the next position to query in the search.  The position
 * is not guaranteed to be in this document's partition.
 * 
 * @param pos an offset within the document
 * @param searchForward the direction of the search
 * @return the next position to query
 */
public int getNextPosition(int pos, boolean searchForward) {
	final ITypedRegion partition= getPartition(pos);
	if (partition == null) return simpleIncrement(pos, searchForward);
	if (fPartition.equals(partition.getType()))
		return simpleIncrement(pos, searchForward);
	if (searchForward) {
		int end= partition.getOffset() + partition.getLength();
		if (pos < end)
			return end;
	} else {
		int offset= partition.getOffset();
		if (pos > offset)
			return offset - 1;
	}
	return simpleIncrement(pos, searchForward);
}
 

@Override
protected IRegion findExtendedDoubleClickSelection(IDocument document, int offset) {
	IRegion match= super.findExtendedDoubleClickSelection(document, offset);
	if (match != null)
		return match;

	try {
		ITypedRegion region= TextUtilities.getPartition(document, fPartitioning, offset, true);
		if (offset == region.getOffset() + fHitDelta || offset == region.getOffset() + region.getLength() - fHitDelta) {
			if (fLeftBorder == 0 && fRightBorder == 0)
				return region;
			if (fRightBorder == -1) {
				String delimiter= document.getLineDelimiter(document.getLineOfOffset(region.getOffset() + region.getLength() - 1));
				if (delimiter == null)
					fRightBorder= 0;
				else
					fRightBorder= delimiter.length();
			}
			return new Region(region.getOffset() + fLeftBorder, region.getLength() - fLeftBorder - fRightBorder);
		}
	} catch (BadLocationException e) {
		return null;
	}
	return null;
}
 

/**
 * Finds the partition containing the given offset.
 * 
 * @param document the document to search
 * @param offset the offset used to find a matching partition
 * @return the partition, or null
 */
public static ITypedRegion getPartition(IStructuredDocument document, int offset) {
  ITypedRegion[] partitions;
  try {
    partitions = TextUtilities.computePartitioning(document,
        IStructuredPartitioning.DEFAULT_STRUCTURED_PARTITIONING, 0,
        document.getLength(), true);
  } catch (BadLocationException e) {
    CorePluginLog.logError(e, "Unexpected bad location exception.");
    return null;
  }

  for (ITypedRegion partition : partitions) {
    if (partition.getOffset() <= offset
        && offset < partition.getOffset() + partition.getLength()) {
      return partition;
    }
  }
  
  return null;
}
 

/**
 * {@inheritDoc}
 * <p>
 * May be replaced or extended by subclasses.
 * </p>
 * 
 * @since 2.2
 */
@Override
public synchronized ITypedRegion getPartition(int offset, boolean preferOpenPartitions) {
	ITypedRegion region = getPartition(offset);
	if (preferOpenPartitions) {
		if (region.getOffset() == offset && !region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE)) {
			if (offset > 0) {
				region = getPartition(offset - 1);
				if (region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE))
					return region;
			}
			return new TypedRegion(offset, 0, IDocument.DEFAULT_CONTENT_TYPE);
		}
	}
	return region;
}
 

@Override
public int nextPosition(int position, boolean forward) {
	ITypedRegion partition= getPartition(position);
	if (fPartition.equals(partition.getType()))
		return super.nextPosition(position, forward);

	if (forward) {
		int end= partition.getOffset() + partition.getLength();
		if (position < end)
			return end;
	} else {
		int offset= partition.getOffset();
		if (position > offset)
			return offset - 1;
	}
	return super.nextPosition(position, forward);
}
 

/**
 * {@inheritDoc}
 * <p>
 * May be replaced or extended by subclasses.
 * </p>
 */
@Override
public ITypedRegion getPartition(int offset, boolean preferOpenPartitions) {
    ITypedRegion region = getPartition(offset);
    if (preferOpenPartitions) {
        if (region.getOffset() == offset && !region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE)) {
            if (offset > 0) {
                region = getPartition(offset - 1);
                if (region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE)) {
                    return region;
                }
            }
            return new TypedRegion(offset, 0, IDocument.DEFAULT_CONTENT_TYPE);
        }
    }
    return region;
}
 

/**
 * {@inheritDoc}
 * <p>
 * May be replaced or extended by subclasses.
 * </p>
 */
public ITypedRegion getPartition(int offset, boolean preferOpenPartitions) {
    ITypedRegion region= getPartition(offset);
    if (preferOpenPartitions) {
        if (region.getOffset() == offset && !region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE)) {
            if (offset > 0) {
                region= getPartition(offset - 1);
                if (region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE))
                    return region;
            }
            return new TypedRegion(offset, 0, IDocument.DEFAULT_CONTENT_TYPE);
        }
    }
    return region;
}
 

public void createPresentation(TextPresentation presentation, ITypedRegion region) {
	if (fScanner == null) {
		// will be removed if deprecated constructor will be removed
		addRange(presentation, region.getOffset(), region.getLength(), fDefaultTextStyle);
		return;
	}

	int lastStart = region.getOffset();
	int length = 0;
	boolean firstToken = true;
	IToken lastToken = Token.UNDEFINED;
	TextStyle lastTextStyle = getTokenTextStyle(lastToken);

	fScanner.setRange(fDocument, lastStart, region.getLength());

	while (true) {
		IToken token = fScanner.nextToken();
		if (token.isEOF())
			break;

		TextStyle textStyle = getTokenTextStyle(token);
		if (lastTextStyle != null && lastTextStyle.equals(textStyle)) {
			length += fScanner.getTokenLength();
			firstToken = false;
		} else {
			if (!firstToken)
				addRange(presentation, lastStart, length, lastTextStyle);
			firstToken = false;
			lastToken = token;
			lastTextStyle = textStyle;
			lastStart = fScanner.getTokenOffset();
			length = fScanner.getTokenLength();
		}
	}

	addRange(presentation, lastStart, length, lastTextStyle);
}
 

/**
 * Guesses if the command operates within a newly created javadoc comment or
 * not. If in doubt, it will assume that the javadoc is new.
 *
 * @param document
 *            the document
 * @param commandOffset
 *            the command offset
 * @return <code>true</code> if the comment should be closed,
 *         <code>false</code> if not
 */
private boolean isNewComment(IDocument document, int commandOffset) {

	try {
		int lineIndex = document.getLineOfOffset(commandOffset) + 1;
		if (lineIndex >= document.getNumberOfLines())
			return true;

		IRegion line = document.getLineInformation(lineIndex);
		ITypedRegion partition = TextUtilities.getPartition(document, fPartitioning, commandOffset, false);
		int partitionEnd = partition.getOffset() + partition.getLength();
		if (line.getOffset() >= partitionEnd)
			return false;

		if (document.getLength() == partitionEnd)
			return true; // partition goes to end of document - probably a
							// new comment

		String comment = document.get(partition.getOffset(), partition.getLength());
		if (comment.indexOf("/*", 2) != -1) //$NON-NLS-1$
			return true; // enclosed another comment -> probably a new
							// comment

		return false;

	} catch (BadLocationException e) {
		return false;
	}
}
 

protected ExtendedJavaContentAssistInvocationContext createContext(ITextViewer viewer, int offset) {
    final RepositoryAccessor repositoryAccessor = new RepositoryAccessor();
    repositoryAccessor.init();
    final GroovyCompilationUnitFactory gcuf = new GroovyCompilationUnitFactory(repositoryAccessor);
    ICompilationUnit newCompilationUnit;
    try {
        final IDocument document = viewer.getDocument();
        GroovyExpressionPartitioner groovyExpressionPartitioner = new GroovyExpressionPartitioner();
        groovyExpressionPartitioner.connect(document);
        ITypedRegion partition = groovyExpressionPartitioner.getPartition(offset);
        String script = document.get(partition.getOffset() + 2, partition.getLength() - 2);
        groovyExpressionPartitioner.disconnect();
        if (script.endsWith("}")) {
            script = script.substring(0, script.length() - 1);
        }
        newCompilationUnit = gcuf.newCompilationUnit(script, new NullProgressMonitor());
        Map<String, ScriptVariable> context = new HashMap<String, ScriptVariable>();
        variableScope.stream().forEach(exp -> context.put(exp.getName(), new ScriptVariable(exp.getName(), exp.getReturnType())));
        ((BonitaScriptGroovyCompilationUnit) newCompilationUnit).setContext(context);
        final Document tmpDocument = new Document(script);
        editorPart.init(null, new FileEditorInput((IFile) newCompilationUnit.getResource()));
        return new ExtendedJavaContentAssistInvocationContext(editorPart, viewer, offset, tmpDocument,
                offset - partition.getOffset() - 2,
                context);
    } catch (final JavaModelException | BadLocationException | PartInitException e) {
        BonitaStudioLog.error(e);
    }
    return null;
}
 

public void createPresentation(TextPresentation presentation, ITypedRegion region) {
	if (fScanner == null) {
		// will be removed if deprecated constructor will be removed
		addRange(presentation, region.getOffset(), region.getLength(), fDefaultTextStyle);
		return;
	}

	int lastStart = region.getOffset();
	int length = 0;
	boolean firstToken = true;
	IToken lastToken = Token.UNDEFINED;
	TextStyle lastTextStyle = getTokenTextStyle(lastToken);

	fScanner.setRange(fDocument, lastStart, region.getLength());

	while (true) {
		IToken token = fScanner.nextToken();
		if (token.isEOF())
			break;

		TextStyle textStyle = getTokenTextStyle(token);
		if (lastTextStyle != null && lastTextStyle.equals(textStyle)) {
			length += fScanner.getTokenLength();
			firstToken = false;
		} else {
			if (!firstToken)
				addRange(presentation, lastStart, length, lastTextStyle);
			firstToken = false;
			lastToken = token;
			lastTextStyle = textStyle;
			lastStart = fScanner.getTokenOffset();
			length = fScanner.getTokenLength();
		}
	}

	addRange(presentation, lastStart, length, lastTextStyle);
}
 

public ITypedRegion[] merge(ITypedRegion[] original) {
	if (original == null || original.length == 0)
		return original;
	ITypedRegion[] result = new ITypedRegion[original.length];
	String contentType = original[0].getType();
	result[0] = original[0];
	for(int i = 1; i < original.length; i++) {
		ITypedRegion copyMe = original[i];
		result[i] = new TypedRegion(copyMe.getOffset(), copyMe.getLength(), contentType);
	}
	return result;
}
 

public void createPresentation(TextPresentation presentation, ITypedRegion region) {
	if (fScanner == null) {
		// will be removed if deprecated constructor will be removed
		addRange(presentation, region.getOffset(), region.getLength(), fDefaultTextStyle);
		return;
	}

	int lastStart = region.getOffset();
	int length = 0;
	boolean firstToken = true;
	IToken lastToken = Token.UNDEFINED;
	TextStyle lastTextStyle = getTokenTextStyle(lastToken);

	fScanner.setRange(fDocument, lastStart, region.getLength());

	while (true) {
		IToken token = fScanner.nextToken();
		if (token.isEOF())
			break;

		TextStyle textStyle = getTokenTextStyle(token);
		if (lastTextStyle != null && lastTextStyle.equals(textStyle)) {
			length += fScanner.getTokenLength();
			firstToken = false;
		} else {
			if (!firstToken)
				addRange(presentation, lastStart, length, lastTextStyle);
			firstToken = false;
			lastToken = token;
			lastTextStyle = textStyle;
			lastStart = fScanner.getTokenOffset();
			length = fScanner.getTokenLength();
		}
	}

	addRange(presentation, lastStart, length, lastTextStyle);
}
 

/**
 * @since 2.8
 */
protected void computeCommentFolding(IXtextDocument xtextDocument, IFoldingRegionAcceptor<ITextRegion> foldingRegionAcceptor, ITypedRegion typedRegion, boolean initiallyFolded)
		throws BadLocationException {
	int offset = typedRegion.getOffset();
	int length = typedRegion.getLength();
	Matcher matcher = getTextPatternInComment().matcher(xtextDocument.get(offset, length));
	if (matcher.find()) {
		TextRegion significant = new TextRegion(offset + matcher.start(), 0);
		((IFoldingRegionAcceptorExtension<ITextRegion>)foldingRegionAcceptor).accept(offset, length, initiallyFolded, significant);
	} else {
		((IFoldingRegionAcceptorExtension<ITextRegion>)foldingRegionAcceptor).accept(offset, length, initiallyFolded);
	}
}
 

/**
 * Returns a position in the first java partition after the last non-empty and non-comment partition.
 * There is no non-whitespace from the returned position to the end of the partition it is contained in.
 *
 * @param document the document being modified
 * @param line the line under investigation
 * @param offset the caret offset into <code>line</code>
 * @param partitioning the document partitioning
 * @return the position of the next Java partition, or the end of <code>line</code>
 */
private static int nextPartitionOrLineEnd(IDocument document, ITextSelection line, int offset, String partitioning) {
	// run relative to document
	final int docOffset= offset + line.getOffset();
	final int eol= line.getOffset() + line.getLength();
	int nextPartitionPos= eol; // init with line end
	int validPosition= docOffset;

	try {
		ITypedRegion partition= TextUtilities.getPartition(document, partitioning, nextPartitionPos, true);
		validPosition= getValidPositionForPartition(document, partition, eol);
		while (validPosition == -1) {
			nextPartitionPos= partition.getOffset() - 1;
			if (nextPartitionPos < docOffset) {
				validPosition= docOffset;
				break;
			}
			partition= TextUtilities.getPartition(document, partitioning, nextPartitionPos, false);
			validPosition= getValidPositionForPartition(document, partition, eol);
		}
	} catch (BadLocationException e) {
	}

	validPosition= Math.max(validPosition, docOffset);
	// make relative to line
	validPosition -= line.getOffset();
	return validPosition;
}
 

/**
 * Returns a segmentation of the line of the given document appropriate for
 * Bidi rendering.
 *
 * @param document the document
 * @param baseLevel the base level of the line
 * @param lineStart the offset of the line
 * @param lineText Text of the line to retrieve Bidi segments for
 * @return the line's Bidi segmentation
 * @throws BadLocationException in case lineOffset is not valid in document
 */
protected static int[] getBidiLineSegments(IDocument document, int baseLevel, int lineStart, String lineText) throws BadLocationException {

	if (lineText == null || document == null)
		return null;

	int lineLength= lineText.length();
	if (lineLength <= 2)
		return null;

	// Have ICU compute embedding levels. Consume these levels to reduce
	// the Bidi impact, by creating selective segments (preceding
	// character runs with a level mismatching the base level).
	// XXX: Alternatively, we could apply TextLayout. Pros would be full
	// synchronization with the underlying StyledText's (i.e. native) Bidi
	// implementation. Cons are performance penalty because of
	// unavailability of such methods as isLeftToRight and getLevels.

	Bidi bidi= new Bidi(lineText, baseLevel);
	if (bidi.isLeftToRight())
		// Bail out if this is not Bidi text.
		return null;

	IRegion line= document.getLineInformationOfOffset(lineStart);
	ITypedRegion[] linePartitioning= TextUtilities.computePartitioning(document, IJavaPartitions.JAVA_PARTITIONING, lineStart, line.getLength(), false);
	if (linePartitioning == null || linePartitioning.length < 1)
		return null;

	int segmentIndex= 1;
	int[] segments= new int[lineLength + 1];
	byte[] levels= bidi.getLevels();
	int nPartitions= linePartitioning.length;
	for (int partitionIndex= 0; partitionIndex < nPartitions; partitionIndex++) {

		ITypedRegion partition = linePartitioning[partitionIndex];
		int lineOffset= partition.getOffset() - lineStart;
		//Assert.isTrue(lineOffset >= 0 && lineOffset < lineLength);

		if (lineOffset > 0
				&& isMismatchingLevel(levels[lineOffset], baseLevel)
				&& isMismatchingLevel(levels[lineOffset - 1], baseLevel)) {
			// Indicate a Bidi segment at the partition start - provided
			// levels of both character at the current offset and its
			// preceding character mismatch the base paragraph level.
			// Partition end will be covered either by the start of the next
			// partition, a delimiter inside a next partition, or end of line.
			segments[segmentIndex++]= lineOffset;
		}
		if (IDocument.DEFAULT_CONTENT_TYPE.equals(partition.getType())) {
			int partitionEnd= Math.min(lineLength, lineOffset + partition.getLength());
			while (++lineOffset < partitionEnd) {
				if (isMismatchingLevel(levels[lineOffset], baseLevel)
						&& String.valueOf(lineText.charAt(lineOffset)).matches(BIDI_DELIMITERS)) {
					// For default content types, indicate a segment before
					// a delimiting character with a mismatching embedding
					// level.
					segments[segmentIndex++]= lineOffset;
				}
			}
		}
	}
	if (segmentIndex <= 1)
		return null;

	segments[0]= 0;
	if (segments[segmentIndex - 1] != lineLength)
		segments[segmentIndex++]= lineLength;

	if (segmentIndex == segments.length)
		return segments;

	int[] newSegments= new int[segmentIndex];
	System.arraycopy(segments, 0, newSegments, 0, segmentIndex);
	return newSegments;
}
 

private boolean isContained(ITypedRegion region, int position, int length) {
  return region.getOffset() <= position
      && position + length <= region.getOffset() + region.getLength();
}
 

@Override
public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer,
    int offsetInDoc) {

  IDocument doc = viewer.getDocument();
  IStructuredDocument structuredDoc = (IStructuredDocument) doc;
  ITypedRegion partition = SseUtilities.getPartition(structuredDoc,
      offsetInDoc);
  if (partition == null) {
    GWTPluginLog.logWarning("Could not generate CSS proposals due to problem getting partition of offset.");
    return null;
  }

  int offsetInExtractedDoc = offsetInDoc - partition.getOffset();
  CssExtractor extractor = CssExtractor.extract(doc, partition.getOffset(),
      partition.getLength(), new CssResourceAwareModelLoader());
  if (extractor == null) {
    GWTPluginLog.logWarning("Could not extract CSS document to generate CSS proposals.");
    return null;
  }

  IndexedRegion indexedNode = extractor.getCssModel().getIndexedRegion(
      offsetInExtractedDoc);
  if (indexedNode == null) {
    indexedNode = (IndexedRegion) extractor.getCssDocument();
  }

  ICompletionProposal[] proposals;
  try {
    proposals = CssProposalArrangerCaller.getProposals(offsetInExtractedDoc,
        (ICSSNode) indexedNode, partition.getOffset(), (char) 0);

    List<ICompletionProposal> newProposals = new ArrayList<ICompletionProposal>();
    for (ICompletionProposal proposal : proposals) {
      newProposals.add(new IndentationFixingCompletionProposal(proposal));
    }

    return newProposals.toArray(new ICompletionProposal[newProposals.size()]);

  } catch (Throwable e) {
    GWTPluginLog.logWarning(e,
        "Could not generate CSS proposals due to failed call to CSS proposal arranger.");
    return null;
  }
}
 

/**
 * Detects the indentation level.
 */
public int detectIndentationLevel(IDocument document, int offset, boolean isSelection,
		IFormattingContext formattingContext)
{

	int indent = 0;
	try
	{
		// detect the indentation offset with the parser, only if the given offset is not the first one in the
		// current partition.
		ITypedRegion partition = document.getPartition(offset);
		if (partition != null && partition.getOffset() == offset)
		{
			return super.detectIndentationLevel(document, offset);
		}

		String source = document.get();
		IParseRootNode parseResult = ParserPoolFactory.parse(getMainContentType(), source).getRootNode();
		if (parseResult != null)
		{
			final XMLFormatterNodeBuilder builder = new XMLFormatterNodeBuilder();
			final FormatterDocument formatterDocument = createFormatterDocument(source, offset);
			IFormatterContainerNode root = builder.build(parseResult, formatterDocument);
			new XMLFormatterNodeRewriter().rewrite(root);
			IFormatterContext context = new XMLFormatterContext(0);
			FormatterIndentDetector detector = new FormatterIndentDetector(offset);
			try
			{
				root.accept(context, detector);
				return detector.getLevel();
			}
			catch (Exception e)
			{
				// ignore
			}
		}
	}
	catch (Throwable t)
	{
		return super.detectIndentationLevel(document, offset);
	}
	return indent;
}