/*******************************************************************************
* Copyright (c) 2011 Red Hat, Inc.
* All rights reserved.
* This program is made available under the terms of the
* Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Red Hat, Inc. - initial API and implementation
******************************************************************************/
package org.eclipse.bpmn2.modeler.ui.views;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.eclipse.bpmn2.Definitions;
import org.eclipse.bpmn2.FlowElement;
import org.eclipse.bpmn2.Lane;
import org.eclipse.bpmn2.LaneSet;
import org.eclipse.bpmn2.Process;
import org.eclipse.bpmn2.RootElement;
import org.eclipse.bpmn2.SequenceFlow;
import org.eclipse.bpmn2.modeler.core.ModelHandler;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.graphiti.mm.pictograms.PictogramLink;
import org.eclipse.graphiti.ui.internal.parts.ContainerShapeEditPart;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IViewSite;
class ViewContentProvider implements IStructuredContentProvider, ITreeContentProvider {
private TreeParent invisibleRoot;
@Override
public void inputChanged(Viewer v, Object oldInput, Object newInput) {
}
@Override
public void dispose() {
}
@Override
public Object[] getElements(Object parent) {
if (parent instanceof IViewSite) {
if (invisibleRoot == null) {
initialize();
}
return getChildren(invisibleRoot);
}
return getChildren(parent);
}
@Override
public Object getParent(Object child) {
if (child instanceof TreeObject) {
return ((TreeObject) child).getParent();
}
return null;
}
@Override
public Object[] getChildren(Object parent) {
if (parent instanceof TreeParent) {
return ((TreeParent) parent).getChildren();
}
return new Object[0];
}
@Override
public boolean hasChildren(Object parent) {
if (parent instanceof TreeParent) {
return ((TreeParent) parent).hasChildren();
}
return false;
}
/*
* We will set up a dummy model to initialize tree heararchy. In a real code, you will connect to a real model and
* expose its hierarchy.
*/
private void initialize() {
invisibleRoot = new TreeParent("");
}
void updateModel(ModelHandler mh) {
invisibleRoot.removeChildren();
if (mh == null) {
return;
}
Definitions definitions = mh.getDefinitions();
List<RootElement> rootElements = definitions.getRootElements();
for (RootElement element : rootElements) {
if (element instanceof Process) {
Process process = (Process) element;
TreeParent proc = new TreeParent("Process");
createLaneSets(proc, process.getLaneSets());
createFlowElementTree(proc, process.getFlowElements());
invisibleRoot.addChild(proc);
}
}
}
private void createLaneSets(TreeParent proc, List<LaneSet> laneSets) {
for (LaneSet laneSet : laneSets) {
createLaneSetTree(proc, laneSet);
}
}
private void createLaneSetTree(TreeParent proc, LaneSet laneSet) {
if (laneSet == null) {
return;
}
for (Lane lane : laneSet.getLanes()) {
TreeParent parent = new TreeParent(lane);
proc.addChild(parent);
createLaneSetTree(parent, lane.getChildLaneSet());
}
}
private void createFlowElementTree(TreeParent proc, List<FlowElement> flowElements) {
for (FlowElement f : flowElements) {
if (!(f instanceof SequenceFlow)) {
TreeObject treeObject = new TreeObject(f);
proc.addChild(treeObject);
}
}
}
@SuppressWarnings("restriction")
public Object[] getSelected(ISelection selection) {
if (selection instanceof StructuredSelection) {
StructuredSelection sel = (StructuredSelection) selection;
List<Object> selected = Arrays.asList(sel.toArray());
if (selected.size() == 0 || !(selected.get(0) instanceof ContainerShapeEditPart)) {
return null;
}
PictogramLink link = ((ContainerShapeEditPart) selected.get(0)).getPictogramElement().getLink();
if (link == null) {
return null;
}
EList<EObject> businessObjects = link.getBusinessObjects();
TreeObject[] children = invisibleRoot.getChildren();
ArrayList<TreeObject> list = getSelectionFromList(businessObjects, children);
return list.toArray();
}
return null;
}
private ArrayList<TreeObject> getSelectionFromList(EList<EObject> businessObjects, TreeObject[] children) {
ArrayList<TreeObject> list = new ArrayList<TreeObject>();
for (TreeObject treeObject : children) {
if (treeObject instanceof TreeParent) {
if (businessObjects.contains(treeObject.getBaseElement())) {
list.add(treeObject);
}
list.addAll(getSelectionFromList(businessObjects, ((TreeParent) treeObject).getChildren()));
} else if (businessObjects.contains(treeObject.getBaseElement())) {
list.add(treeObject);
}
}
return list;
}
}