Java 类org.eclipse.core.runtime.PlatformObject 实例源码

private PlatformObject[] buildHierarchyRoots(
    GraphModel master, Collection<GraphNode> nodes) {
  List<PlatformObject> staging = Lists.newArrayList();

  List<GraphNode> remains = Lists.newArrayList(nodes);

  Collection<GraphNode> collapseNodes = getCollapseTreeModel().computeNodes();
  if (!collapseNodes.isEmpty()) {
    staging.add(buildCollapseRoot());
    remains.removeAll(collapseNodes);
  }

  for (GraphEdgeMatcherDescriptor matcher : getTreeDescriptors()) {
    staging.add(buildTreeRoot(master, remains, matcher));
  }

  staging.add(buildRemainsRoot(remains));
  PlatformObject[] result = new PlatformObject[staging.size()];
  return staging.toArray(result);
}

/**
 * The argument for {@code remains} is updated on each call.
 */
private PlatformObject buildTreeRoot(
    GraphModel master,
    Collection<GraphNode> remains,
    GraphEdgeMatcherDescriptor matcher) {

  // Build the hierarchy for this set of nodes and matcher
  GraphModel treeGraph = GraphBuilders.buildFromNodes(master, remains);
  GraphData<GraphNode> data = GraphData.createGraphData(
      NodeTreeProviders.GRAPH_NODE_PROVIDER,
      treeGraph, matcher.getInfo());

  // Update remains with info from hierarchy tree
  TreeModel tree = data.getTreeModel();
  remains.removeAll(tree.computeTreeNodes());

  // provide the root viewing object
  String label = MessageFormat.format("Tree of {0}", matcher.getName());
  return new ActionTreeRoot(data, label, matcher);
}

public void debugContextChanged(DebugContextEvent event) {
    if ((event.getFlags() & DebugContextEvent.ACTIVATED) > 0) {
        PlatformObject object = (PlatformObject) ((IStructuredSelection) event.getContext()).getFirstElement();
        if (object == null)
            return;
        IDebugTarget newTarget = (IDebugTarget) object.getAdapter(IDebugTarget.class);
        if (newTarget != debugTarget && newTarget != null && !newTarget.isTerminated()) {
            debugTarget = newTarget;
        }
    }
}

@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public PlatformObject buildViewerRoots() {
  List<PlatformObject> result = Lists.newArrayList();

  TreeModel.Flat model = new TreeModel.Flat(nodes);
  solo = new GraphData(provider, model);
  result.add(new SolitaryRoot(solo, listLabel));
  return new ViewerRoot(result.toArray());
}

private PlatformObject buildCollapseRoot() {

    CollapseTreeModel treeModel = getCollapseTreeModel();
    int rootCnt = treeModel.computeRoots().size();
    int nodeCnt = treeModel.computeNodes().size();

    String label = MessageFormat.format(
        "Collapse nodes [{0} roots, {1} nodes]", rootCnt, nodeCnt);
    return CollapseTreeRoot.build(
        label, treeModel, NodeTreeProviders.GRAPH_NODE_PROVIDER);
  }

private PlatformObject buildRemainsRoot(Collection<GraphNode> nodes) {
  TreeModel.Flat model = new TreeModel.Flat(nodes);
  GraphData<GraphNode> data = new GraphData<GraphNode>(
      NodeTreeProviders.GRAPH_NODE_PROVIDER, model);
  String label = MessageFormat.format("Solitaires [{0} nodes]", nodes.size());
  return new ActionRemainsRoot(data, label);
}

/**
 * Provides the results for the 
 * {@link ViewEditorNodeViewerProvider#buildViewerRoots()}
 * this is returned by {@link #getNodeViewProvider()}.
 */
public ViewerRoot buildViewerRoot() {
  Collection<GraphNode> nodes = viewInfo.getViewNodes();
  PlatformObject[] roots = compactor.buildRoots(nodes);

  String label = buildNodeViewerLabel(roots.length, nodes.size());

  TreeViewerObject view = new TreeViewerObject(label, roots);
  return new ViewerRoot(new Object[] {view});
}

/**Called automagically by Eclipse.
 * I use this fct to filter the resources we decide to decorate or not.
 * see effectiveDecorate method, which effectively affect the IDecoration */
@Override
public void decorate(Object element, IDecoration decoration) {
    /* we only decorate IResources (IFile / IFolder mainly) but some awkward
     * classes are not in the IResource object tree, but are convertible
     * into IResources...
     * This happens for CContainers which are like folder in the CDT model.
     * This block tries to decorate these resources. The catch block occurs
     * when the element is neither in the IResource tree, nor convertible.
     */
    if(!(element instanceof IResource)){
        if (!(element instanceof PlatformObject)) return;

        // try the conversion thing for PlateformObject things
        try {
            IResource ir = (IResource) ((PlatformObject) element).getAdapter(IResource.class);
            if (ir != null && ir.isDerived())
                effectiveDecorateDerived(ir, decoration);
        } catch (Exception e) {
            info("element " + element.toString() + " not usable. "
                    + "Type is " + element.getClass().getCanonicalName());
        }
        return;
    }

    // easy case. Item is an IResource child.
    IResource objectResource = (IResource) element;

    if(FilterManager.isActiveConfFile(objectResource))
        effectiveDecorateConfFile(objectResource, decoration);

    if(objectResource.isDerived())
        effectiveDecorateDerived(objectResource, decoration);
}

private PlatformObject getParent(TreeViewerObject root) {
  return root.getParent();
}

public TreeViewerObject(String name, PlatformObject[] children) {
  this(name, null, children);
}

public TreeViewerObject(
    String name, PlatformObject parent, PlatformObject[] children) {
  this.name = name;
  this.parent = parent;
  this.children = children;
}

public PlatformObject getParent() {
  return parent;
}

public PlatformObject[] getChildren() {
  return children;
}

public void refresh() {
  PlatformObject treeRoots = provider.buildViewerRoots();
  treeViewer.setInput(treeRoots);
  provider.updateExpandState(treeViewer);
  treeViewer.refresh();
}

public ActionViewerObject(String name, PlatformObject[] children) {
  super(name, children);
}

public ActionViewerObject(
    String name, PlatformObject parent, PlatformObject[] children) {
  super(name, parent, children);
}

public PlatformObject[] buildRoots(Collection<GraphNode> nodes) {
  roots = buildHierarchyRoots(editor.getViewGraph(), nodes);
  return roots;
}

private static <T> T getAdapterOfNonPlatformObjectFromRegistry( Object adaptable, Class<T> adapterType) {
  if( !( adaptable instanceof PlatformObject ) ) {
    return getAdapterFromRegistry( adaptable, adapterType );
  }
  return null;
}

PlatformObject buildViewerRoots();