Java Code Examples for org.eclipse.xtext.util.ITextRegion#EMPTY_REGION

public void open(IOutlineNode node, ISourceViewer textViewer) {
	if (node != null) {
		ITextRegion textRegion = node.getSignificantTextRegion();
		if (textRegion != null && textRegion != ITextRegion.EMPTY_REGION) {
			int offset = textRegion.getOffset();
			int length = textRegion.getLength();
			textViewer.setRangeIndication(offset, length, true);
			textViewer.revealRange(offset, length);
			textViewer.setSelectedRange(offset, length);
		} else {
			node.tryReadOnly(new IUnitOfWork.Void<EObject>() {
				@Override
				public void process(EObject state) throws Exception {
					openEObject(state);
				}
			});
		}
		
	}
}
 

/**
 * @since 2.3
 */
protected ITextRegion createRegion(List<INode> nodes, RegionDescription query) {
	if (query == RegionDescription.FULL || query == RegionDescription.SIGNIFICANT)
		return createRegion(nodes);
	ITextRegion result = ITextRegion.EMPTY_REGION;
	for (INode node : nodes) {
		for(INode leafNode: node.getLeafNodes()) {
			if (!isHidden(leafNode, query)) {
				ITextRegionWithLineInformation region = leafNode.getTextRegionWithLineInformation();
				if (region.getLength() != 0) {
					result = result.merge(toZeroBasedRegion(region));
				}
			}
		}
	}
	return result;
}
 

@Override
public TreeConstructionReport serializeSubtree(EObject object, ITokenStream out) throws IOException {
	TreeConstructionReportImpl report = createReport(object);
	AbstractToken root = serialize(object, report);
	Set<ICompositeNode> roots = Sets.newHashSet();
	Map<EObject, AbstractToken> obj2token = Maps.newHashMap();
	collectRootsAndEObjects(root, obj2token, roots);
	//		dump("", root);
	Map<ILeafNode, EObject> comments = commentAssociater.associateCommentsWithSemanticEObjects(object, roots);
	for (ICompositeNode r : roots)
		assignNodesByMatching(obj2token, r, comments);
	WsMergerStream wsout = new WsMergerStream(out);
	//		dump("", root);
	//		System.out.println(EmfFormatter.objToStr(roots.iterator().next(),
	//				ParsetreePackage.Literals.ABSTRACT_NODE__TOTAL_LENGTH,
	//				ParsetreePackage.Literals.ABSTRACT_NODE__TOTAL_OFFSET,
	//				ParsetreePackage.Literals.ABSTRACT_NODE__TOTAL_LINE, ParsetreePackage.Literals.ABSTRACT_NODE__PARENT));
	ITextRegion previousLocation = ITextRegion.EMPTY_REGION;
	initStream(root, wsout);
	previousLocation = write(root, wsout, previousLocation);
	wsout.flush();
	report.setPreviousLocation(previousLocation);
	return report;
}
 

public ITreeAppendable traceSignificant(ITreeAppendable appendable, EObject source, boolean useForDebugging) {
	if (appendable instanceof TreeAppendable) {
		return ((TreeAppendable) appendable).trace(source,
				ILocationInFileProviderExtension.RegionDescription.SIGNIFICANT, useForDebugging);
	} else {
		ITextRegionWithLineInformation it = (ITextRegionWithLineInformation) locationProvider
				.getSignificantTextRegion(source);
		if (it != null && it != ITextRegion.EMPTY_REGION) {
			return appendable.trace(new LocationData(it.getOffset(), it.getLength(), it.getLineNumber(),
					it.getEndLineNumber(), null), useForDebugging);
		} else {
			return appendable;
		}
	}
}
 

/**
 * A {@link BackgroundOutlineTreeProvider} must use
 * {@link #AbstractOutlineNode(IOutlineNode, ImageDescriptor, Object, boolean)} instead.
 */
protected AbstractOutlineNode(IOutlineNode parent, Image image, Object text, boolean isLeaf) {
	this.text = text == null ? "<unnamed>" : text;
	this.image = image;
	this.isLeaf = isLeaf;
	setParent(parent);
	textRegion = ITextRegion.EMPTY_REGION;
}
 

/**
 * @since 2.4
 */
protected AbstractOutlineNode(IOutlineNode parent, ImageDescriptor imageDescriptor, Object text, boolean isLeaf) {
	this.text = text == null ? "<unnamed>" : text;
	this.imageDescriptor = imageDescriptor;
	this.isLeaf = isLeaf;
	setParent(parent);
	textRegion = ITextRegion.EMPTY_REGION;
}
 

public ITextRegion selectLast(XtextResource resource, ITextRegion currentEditorSelection) {
	if (selectionHistory.isEmpty()) {
		return ITextRegion.EMPTY_REGION;
	}
	if (!currentEditorSelection.equals(selectionHistory.pop())) {
		selectionHistory.clear();
		return ITextRegion.EMPTY_REGION;
	}
	return selectionHistory.isEmpty() ? ITextRegion.EMPTY_REGION : selectionHistory.peek();
}
 

public ITextRegion selectEnclosing(XtextResource resource, ITextRegion currentEditorSelection) {
	Pair<EObject, EObject> currentlySelected = getSelectedAstElements(resource, currentEditorSelection);
	if (currentlySelected == null) {
		IParseResult parseResult = resource.getParseResult();
		if (parseResult != null) {
			ICompositeNode rootNode = parseResult.getRootNode();
			int offset = getSelectionOffset(rootNode, currentEditorSelection);
			INode node = findLeafNodeAtOffset(rootNode, offset);
			if (node != null) {
				ITextRegion fineGrainedRegion = computeInitialFineGrainedSelection(node, currentEditorSelection);
				if (fineGrainedRegion != null) {
					selectionHistory.clear();
					register(currentEditorSelection);
					return register(fineGrainedRegion);
				}
				EObject eObject = findSemanticObjectFor(node);
				return register(getTextRegion(eObject));
			}
		}
	} else {
		EObject first = currentlySelected.getFirst();
		if (first.eContainer() != null) {
			return register(getTextRegion(first.eContainer()));
		}
	}
	return ITextRegion.EMPTY_REGION;
}
 

public ITextRegion selectNext(XtextResource resource, ITextRegion currentEditorSelection) {
	Pair<EObject, EObject> currentlySelected = getSelectedAstElements(resource, currentEditorSelection);
	if (currentlySelected == null) {
		return selectEnclosing(resource, currentEditorSelection);
	}
	EObject second = currentlySelected.getSecond();
	EObject nextSibling = EcoreUtil2.getNextSibling(second);
	if (nextSibling != null) {
		return register(getRegion(Tuples.create(currentlySelected.getFirst(), nextSibling)));
	} else {
		if (second.eContainer() == null)
			return ITextRegion.EMPTY_REGION;
		return register(getRegion(Tuples.create(second.eContainer(), second.eContainer())));
	}
}
 

public ITextRegion selectPrevious(XtextResource resource, ITextRegion currentEditorSelection) {
	Pair<EObject, EObject> currentlySelected = getSelectedAstElements(resource, currentEditorSelection);
	if (currentlySelected == null) {
		return selectEnclosing(resource, currentEditorSelection);
	}
	EObject first = currentlySelected.getFirst();
	EObject previousSibling = EcoreUtil2.getPreviousSibling(first);
	if (previousSibling != null) {
		return register(getRegion(Tuples.create(previousSibling,currentlySelected.getSecond())));
	} else {
		if (first.eContainer() == null)
			return ITextRegion.EMPTY_REGION;
		return register(getRegion(Tuples.create(first.eContainer(), first.eContainer())));
	}
}
 

protected ITextRegion register(ITextRegion textRegion) {
	if (textRegion == null) {
		return ITextRegion.EMPTY_REGION;
	}
	if (selectionHistory.isEmpty() || !selectionHistory.peek().equals(textRegion)) {
		selectionHistory.push(textRegion);
	}
	return textRegion;
}
 

@Override
public void run() {
	ITextSelection selection = (ITextSelection) xtextEditor.getSelectionProvider().getSelection();
	ITextRegion currentEditorSelection = new TextRegion(selection.getOffset(), selection.getLength());
	ITextRegion nextSelection = xtextEditor.getDocument().priorityReadOnly(createTextSelectionWork(currentEditorSelection));
	if (nextSelection == null || nextSelection == ITextRegion.EMPTY_REGION
			|| nextSelection.equals(currentEditorSelection)) {
		return;
	}
	xtextEditor.selectAndReveal(nextSelection.getOffset(), nextSelection.getLength());
}
 

/**
 * @since 2.3
 */
protected ITextRegion doGetTextRegion(EObject obj, /* @NonNull */ RegionDescription query) {
	ICompositeNode node = findNodeFor(obj);
	if (node == null) {
		if (obj.eContainer() == null)
			return ITextRegion.EMPTY_REGION;
		return getTextRegion(obj.eContainer(), query);
	}
	List<INode> nodes = null;
	if (query == RegionDescription.SIGNIFICANT)
		nodes = getLocationNodes(obj);
	if (nodes == null || nodes.isEmpty())
		nodes = Collections.<INode>singletonList(node);
	return createRegion(nodes, query);
}
 

protected ITextRegion createRegion(final List<INode> nodes) {
	ITextRegion result = ITextRegion.EMPTY_REGION;
	for (INode node : nodes) {
		if (!isHidden(node)) {
			ITextRegionWithLineInformation region = node.getTextRegionWithLineInformation();
			if (region.getLength() != 0) {
				result = result.merge(toZeroBasedRegion(region));
			}
		}
	}
	return result;
}
 

protected ITextRegion computeSelectedText(IWorkbenchPartSelection workbenchPartSelection) {
	return ITextRegion.EMPTY_REGION;
}
 

@Override
public ITextRegion getSignificantTextRegion(EObject element) {
	if (element instanceof RichStringLiteral) {
		ICompositeNode elementNode = findNodeFor(element);
		if (elementNode == null) {
			return ITextRegion.EMPTY_REGION;
		}
		ITextRegion result = ITextRegion.EMPTY_REGION;
		for (INode node : elementNode.getLeafNodes()) {
			if (isHidden(node)) {
				continue;
			}
			EObject grammarElement = node.getGrammarElement();
			if (!(grammarElement instanceof RuleCall)) {
				continue;
			}
			RuleCall ruleCall = (RuleCall) grammarElement;
			
			ITextRegionWithLineInformation region = node.getTextRegionWithLineInformation();
			int offset = region.getOffset();
			int length = region.getLength();
			if (grammarAccess.getRICH_TEXTRule() == ruleCall.getRule()) {
				offset += 3;
				length -= 6;
			} else if (grammarAccess.getRICH_TEXT_STARTRule() == ruleCall.getRule()) {
				offset += 3;
				length -= 4;
			} else if (grammarAccess.getRICH_TEXT_ENDRule() == ruleCall.getRule()) {
				offset += 1;
				length -= 4;
			} else if (grammarAccess.getRICH_TEXT_INBETWEENRule() == ruleCall.getRule()) {
				offset += 1;
				length -= 2;
			} else if (grammarAccess.getCOMMENT_RICH_TEXT_ENDRule() == ruleCall.getRule()) {
				offset += 2;
				length -= 5;
			} else if (grammarAccess.getCOMMENT_RICH_TEXT_INBETWEENRule() == ruleCall.getRule()) {
				offset += 2;
				length -= 3;
			} else {
				continue;
			}
			result = result.merge(toZeroBasedRegion(new TextRegionWithLineInformation(offset, length, region.getLineNumber(), region.getEndLineNumber())));
		}
		return result;
	}
	return super.getSignificantTextRegion(element);
}