org.eclipse.xtext.ui.editor.outline.impl.DocumentRootNode Java Examples

@Override
protected void internalCreateChildren(final DocumentRootNode parentNode, final EObject modelElement) {
  CheckCatalog catalog = (CheckCatalog) modelElement;
  if (catalog.getPackageName() != null) {
    getOutlineNodeFactory().createEStructuralFeatureNode(parentNode, catalog, CheckPackage.Literals.CHECK_CATALOG__PACKAGE_NAME, ImageDescriptor.createFromImage(checkImages.forPackage()), catalog.getPackageName(), true);
  }

  if (catalog.getImports() != null && !catalog.getImports().getImportDeclarations().isEmpty()) {
    EStructuralFeatureNode importNode = getOutlineNodeFactory().createEStructuralFeatureNode(parentNode, catalog, CheckPackage.Literals.CHECK_CATALOG__IMPORTS, ImageDescriptor.createFromImage(checkImages.forImportContainer()), "Import declarations", false);
    for (final org.eclipse.xtext.xtype.XImportDeclaration imported : catalog.getImports().getImportDeclarations()) {
      createNode(importNode, imported);
    }
  }

  EObjectNode catalogNode = createNode(parentNode, catalog);

  for (final Category category : catalog.getCategories()) {
    createNode(catalogNode, category);
  }
  for (final Check check : catalog.getChecks()) {
    createNode(catalogNode, check);
  }

}
 

@SuppressWarnings("unused")
@Test public void testEquivalentIndex() throws Exception {
	DocumentRootNode rootNode = new DocumentRootNode(image, "Root", null, null);
	EObjectNode node = new EObjectNode(eObject, rootNode, image, "Node", false);

	DocumentRootNode rootNode2 = new DocumentRootNode(image, "Root", null, null);
	EObjectNode node2 = new EObjectNode(eObject, rootNode2, image, "Node", false);
	assertTrue(comparer.equals(node, node2));
	EObjectNode node3 = new EObjectNode(eObject, rootNode2, image, "OtherNode", false);
	assertTrue(comparer.equals(node, node2));
	
	DocumentRootNode rootNode3 = new DocumentRootNode(image, "Root", null, null);
	EObjectNode node4 = new EObjectNode(eObject, rootNode3, image, "OtherNode", false);
	EObjectNode node5 = new EObjectNode(eObject, rootNode3, image, "Node", false);
	assertTrue(comparer.equals(node, node5));
	EObjectNode node6 = new EObjectNode(eObject, rootNode3, image, "OtherNode", false);
	assertFalse(comparer.equals(node, node5));
}
 

/** Create a node for the SARL script.
 *
 * @param parentNode the parent node.
 * @param modelElement the feature container for which a node should be created.
 */
protected void _createChildren(DocumentRootNode parentNode, SarlScript modelElement) {
	if (!Strings.isNullOrEmpty(modelElement.getPackage())) {
		// Create the node for the package declaration.
		createEStructuralFeatureNode(
				parentNode, modelElement,
				XtendPackage.Literals.XTEND_FILE__PACKAGE,
				this.imageDispatcher.invoke(getClass().getPackage()),
				// Do not use the text dispatcher below for avoiding to obtain
				// the filename of the script.
				modelElement.getPackage(),
				true);
	}
	// Create the nodes for the import declarations.
	/*if (modelElement.getImportSection() != null && !modelElement.getImportSection().getImportDeclarations().isEmpty()) {
		createNode(parentNode, modelElement.getImportSection());
	}*/
	// Create a node per type declaration.
	for (final XtendTypeDeclaration topElement : modelElement.getXtendTypes()) {
		createNode(parentNode, topElement);
	}
}
 

@Override
protected void _createChildren(DocumentRootNode parentNode,
		EObject modelElement) {
	if (modelElement instanceof HtmlLabel) {
		HtmlLabel htmlLabel = (HtmlLabel) modelElement;
		/**
		 * Skip the root element, represent only its children.
		 */
		for (HtmlContent htmlContent : htmlLabel.getParts()) {
			if (htmlContent.getText() != null
					&& !htmlContent.getText().trim().isEmpty()) {
				createNode(parentNode, htmlContent);
			} else {
				if (htmlContent.getTag() != null) {
					createNode(parentNode, htmlContent.getTag());
				}
			}
		}
	} else {
		super._createChildren(parentNode, modelElement);
	}
}
 

protected void _createChildren(DocumentRootNode parentNode,
		Program program) {
	for (Class c : program.getClasses()) {
		createNode(parentNode, c);
	}
	if (program.getMain() != null)
		createNode(parentNode, program.getMain());
}
 

/**
 * Default for createNodeDispatcher with document root as a parent node.
 *
 * @param parentNode
 *          the {@link DocumentRootNode}
 * @param modelElement
 *          the {@link EObject} model element
 */
// CHECKSTYLE:CHECK-OFF Name (dispatcher enforces names starting with underscore)
protected void _createNode(final DocumentRootNode parentNode, final EObject modelElement) {
  // CHECKSTYLE:CHECK-ON
  Object text = textDispatcher.invoke(modelElement);
  if (text == null) {
    text = modelElement.eResource().getURI().trimFileExtension().lastSegment();
  }
  factory.createEObjectNode(parentNode, modelElement, imageDispatcher.invoke(modelElement), text, isLeafDispatcher.invoke(modelElement));
}
 

/**
 * Default for createChildrenDispatcher with outline node as a parent node.
 *
 * @param parentNode
 *          the {@link IOutlineNode}
 * @param modelElement
 *          the {@link EObject} model element
 */
// CHECKSTYLE:CHECK-OFF Name (dispatcher enforces names starting with underscore)
public void _createChildren(final IOutlineNode parentNode, final EObject modelElement) {
  // CHECKSTYLE:CHECK-ON
  if (modelElement != null && parentNode.hasChildren()) {
    if (parentNode instanceof DocumentRootNode) {
      internalCreateChildren((DocumentRootNode) parentNode, modelElement);
    } else if (parentNode instanceof EStructuralFeatureNode) {
      internalCreateChildren((EStructuralFeatureNode) parentNode, modelElement);
    } else {
      internalCreateChildren(parentNode, modelElement);
    }
  }
}
 

/**
 * Create the child nodes for a given native Context. We only show quick fixes.
 * 
 * @param parentNode
 *          the parent node
 * @param modelElement
 *          the scope model
 */
//CHECKSTYLE:OFF
protected void _createChildren(final DocumentRootNode parentNode, final ScopeModel modelElement) {
  //CHECKSTYLE:ON
  Image importContainerImage = JavaPlugin.getImageDescriptorRegistry().get(JavaPluginImages.DESC_OBJS_IMPCONT);

  if (!modelElement.getImports().isEmpty()) {
    createEStructuralFeatureNode(parentNode, modelElement, ScopePackage.Literals.SCOPE_MODEL__IMPORTS, importContainerImage, "import declarations", false);
  }

  for (EObject content : modelElement.getScopes()) {
    createNode(parentNode, content);
  }
}
 

/**
 * Do not create Model nodes in the outline. When the valid model is processed it is not
 * added to the outline but its children are.
 * 
 * @param parentNode
 *          the parent node, this should be the tree root
 * @param modelElement
 *          a valid model
 */
// CHECKSTYLE:OFF
protected void _createChildren(final DocumentRootNode parentNode, final ValidModel modelElement) {
  // CHECKSTYLE:ON

  Image importContainerImage = JavaPlugin.getImageDescriptorRegistry().get(JavaPluginImages.DESC_OBJS_IMPCONT);

  if (!modelElement.getImports().isEmpty()) {
    createEStructuralFeatureNode(parentNode, modelElement, ValidPackage.Literals.VALID_MODEL__IMPORTS, importContainerImage, "import declarations", false);
  }
  for (EObject content : modelElement.getCategories()) {
    createNode(parentNode, content);
  }
}
 

@Override
public IXtendOutlineContext buildXtendNode(EObject modelElement, IXtendOutlineContext context) {
	IXtendOutlineContext resultedContext = super.buildXtendNode(modelElement, context);
	
	if (!context.isShowInherited()) {
		EclipseXtendOutlineContext eclipseXtendOutlineContext = (EclipseXtendOutlineContext) context;
		IOutlineNode parentNode = eclipseXtendOutlineContext.getParentNode();
		if (parentNode instanceof DocumentRootNode) {
			if (modelElement instanceof JvmDeclaredType) {
				JvmDeclaredType jvmDeclaredType = (JvmDeclaredType) modelElement;
				String packageName = jvmDeclaredType.getPackageName();
				if (packageName != null) {
					EObject rootElement = modelElement.eResource().getContents().get(0);
					if (rootElement instanceof XtendFile) {
						XtendFile xtendFile = (XtendFile) rootElement;
						String primaryPackage = xtendFile.getPackage();
						if (!packageName.equals(primaryPackage)) {
							EObjectNode typeNode = (EObjectNode) ((EclipseXtendOutlineContext) resultedContext).getParentNode();
							if (typeNode.getText() instanceof StyledString) {
								typeNode.setText(((StyledString) typeNode.getText()).append(new StyledString(" - "
										+ packageName, StyledString.QUALIFIER_STYLER)));
							}
						}
					}
				}
			}
		}
	}
	return resultedContext;
}
 

protected void _createNode(DocumentRootNode parentNode, Grammar grammar) {
	// Hack: we use this hook to calculate unused rule
	calledRules = Sets.newHashSet();
	if (!grammar.getRules().isEmpty()) {
		UsedRulesFinder usedRulesFinder = new UsedRulesFinder(calledRules);
		usedRulesFinder.compute(grammar);
	}
	super._createNode(parentNode, grammar);
}
 

@Test public void testPropertyEquality() {
	EObjectNode node = new EObjectNode(eObject, null, image, new StyledString("Node"), false);
	assertFalse(comparer.equals(node, new DocumentRootNode(image, new StyledString("Node"), null, null)));
	assertTrue(comparer.equals(node, new EObjectNode(OutlineTestFactory.eINSTANCE.createElement(), null, image, new StyledString("Node"), false)));
	assertFalse(comparer.equals(node, new EObjectNode(eObject, node, image, new StyledString("Node"), false)));
	assertFalse(comparer.equals(node, new EObjectNode(eObject, null, image2, new StyledString("Node"), false)));
	assertFalse(comparer.equals(node, new EObjectNode(eObject, null, image, new StyledString("Node2"), false)));
	assertTrue(comparer.equals(node, new EObjectNode(eObject, null, image, "Node", false)));
}
 

@Test public void testCreateRoot() throws Exception {
	XtextDocument document = createXtextDocument("element {}");
	IOutlineNode rootNode = treeProvider.createRoot(document);
	assertTrue(rootNode instanceof DocumentRootNode);
	assertEquals(treeProvider, ((DocumentRootNode)rootNode).getTreeProvider());
	assertEquals(new TextRegion(0, 10), rootNode.getFullTextRegion());
	assertEquals(new TextRegion(0, 10), rootNode.getSignificantTextRegion());
	assertEquals(document, ((DocumentRootNode) rootNode).getDocument());
}
 

protected DocumentRootNode createRootNode() {
	XtextDocument document = get(XtextDocument.class);
	document.setInput(resource);
	IOutlineTreeStructureProvider treeStructureProvider = new IOutlineTreeStructureProvider() {
		@Override
		public void createChildren(IOutlineNode parentNode, EObject modelElement) {
			new EObjectNode(child0Element, parentNode, (ImageDescriptor) null, "child", false);
		}
	};
	DocumentRootNode rootNode = new DocumentRootNode((ImageDescriptor) null, "root", document, treeStructureProvider);
	return rootNode;
}
 

@Test public void testStateAccess() {
	DocumentRootNode rootNode = createRootNode();
	EObjectNode parentNode = new EObjectNode(parentElement, rootNode, (ImageDescriptor) null, "parent", false);
	EStructuralFeatureNode featureNode = new EStructuralFeatureNode(parentElement,
			OutlineTestPackage.Literals.ELEMENT__XREFS, parentNode, (ImageDescriptor) null, "eClassifiers", true);
	IUnitOfWork<Boolean, EObject> work = new IUnitOfWork<Boolean, EObject>() {
		@Override
		public Boolean exec(EObject state) throws Exception {
			return state != null;
		}
	};
	assertTrue(rootNode.readOnly(work));
	assertTrue(parentNode.readOnly(work));
	assertTrue(featureNode.readOnly(work));
}
 

@Test public void testMethodsDelegateToParent() {
	DocumentRootNode rootNode = createRootNode();
	EObjectNode parentNode = new EObjectNode(parentElement, rootNode, (ImageDescriptor) null, "parent", false);
	assertNotNull(parentNode.getDocument());
	assertNotNull(parentNode.getTreeProvider());
	assertEquals(rootNode.getDocument(), parentNode.getDocument());
	assertEquals(rootNode.getTreeProvider(), parentNode.getTreeProvider());
}
 

protected void _createChildren(DocumentRootNode parentNode,
		FjCachedProgram program) {
	super._createChildren(parentNode, program.getCachedprogram());
}
 

@Override
public void internalCreateChildren(DocumentRootNode parentNode, EObject modelElement) {
	IXtendOutlineContext context = newContext(parentNode);
	xtendOutlineTreeBuilder.build(modelElement, context);
}
 

@Override
protected void _createChildren(DocumentRootNode parentNode, EObject rootElement) {
	for (EObject content : rootElement.eContents()) {
		createNode(parentNode, content);
	}
}
 

@Test public void testCreateChildrenLazily() {
	DocumentRootNode rootNode = createRootNode();
	EObjectNode parentNode = new EObjectNode(parentElement, rootNode, (ImageDescriptor) null, "parent", false);
	assertFalse(parentNode.getChildren().isEmpty());
}
 

/**
 * Do not create Model nodes in the outline if the model node itself is not specified as required element.
 * In that case, when the valid model is processed it is not added to the outline but its children are.
 *
 * @param parentNode
 *          the parent {@link IOutlineNode}
 * @param modelElement
 *          a valid {@link EObject}
 */
@Override
protected void internalCreateChildren(final DocumentRootNode parentNode, final EObject modelElement) {
  if (getRelevantElements().contains(modelElement.eClass())) {
    createNode(parentNode, modelElement);
  } else {
    createChildrenDispatcher.invoke(parentNode, modelElement);
  }
}
 

/**
 * Default for createChildrenDispatcher with document root as a parent node.
 *
 * @param parentNode
 *          the {@link DocumentRootNode}
 * @param modelElement
 *          the {@link EObject} model element
 */
// CHECKSTYLE:CHECK-OFF Name (dispatcher enforces names starting with underscore)
public void _createChildren(final DocumentRootNode parentNode, final EObject modelElement) {
  // CHECKSTYLE:CHECK-ON
  internalCreateChildren((IOutlineNode) parentNode, modelElement);
}
 

/** Create a node for the given feature container at the root level.
 *
 * @param parentNode the parent node.
 * @param modelElement the feature container for which a node should be created.
 */
protected void _createNode(DocumentRootNode parentNode, XtendTypeDeclaration modelElement) {
	createTypeDeclarationNode(parentNode, modelElement);
}