| /******************************************************************************* |
| * Copyright (c) 2004, 2007 Boeing. |
| * All rights reserved. This program and the accompanying materials |
| * are 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: |
| * Boeing - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.osee.ote.ui.define.viewers; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.nebula.widgets.xviewer.XViewer; |
| import org.eclipse.osee.framework.core.data.IOseeBranch; |
| import org.eclipse.osee.framework.core.exception.AttributeDoesNotExist; |
| import org.eclipse.osee.framework.jdk.core.type.OseeCoreException; |
| import org.eclipse.osee.framework.skynet.core.artifact.Artifact; |
| import org.eclipse.osee.framework.ui.skynet.artifact.massEditor.MassXViewerFactory; |
| import org.eclipse.osee.framework.ui.swt.Displays; |
| import org.eclipse.osee.ote.define.artifacts.ArtifactTestRunOperator; |
| import org.eclipse.osee.ote.ui.define.viewers.data.ArtifactItem; |
| import org.eclipse.osee.ote.ui.define.viewers.data.BranchItem; |
| import org.eclipse.osee.ote.ui.define.viewers.data.DataItem; |
| import org.eclipse.osee.ote.ui.define.viewers.data.ScriptItem; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.TreeItem; |
| |
| /** |
| * @author Roberto E. Escobar |
| */ |
| public class XViewerDataManager { |
| |
| private final XViewer xViewer; |
| private final List<DataItem> commitableItems; |
| private final List<DataItem> uncommitableItems; |
| private final Map<IOseeBranch, DataItem> branchMap; |
| private final List<DataItem> backingData; |
| private final Collection<IDataChangedListener> listeners; |
| private boolean isInitialized; |
| |
| public XViewerDataManager(XViewer xViewer) { |
| super(); |
| this.backingData = new ArrayList<>(); |
| this.isInitialized = false; |
| this.xViewer = xViewer; |
| this.branchMap = new HashMap<>(); |
| this.commitableItems = new ArrayList<>(); |
| this.uncommitableItems = new ArrayList<>(); |
| this.listeners = Collections.synchronizedSet(new HashSet<IDataChangedListener>()); |
| } |
| |
| private void ensureInitialized() { |
| if (isInitialized != true) { |
| isInitialized = true; |
| Displays.ensureInDisplayThread(new Runnable() { |
| @Override |
| public void run() { |
| xViewer.setInput(backingData); |
| } |
| }); |
| } |
| } |
| |
| public void addArtifacts(IProgressMonitor monitor, final List<Artifact> artifacts) throws OseeCoreException, AttributeDoesNotExist { |
| if (branchMap.isEmpty()) { |
| if (xViewer.getXViewerFactory() instanceof MassXViewerFactory) { |
| ((MassXViewerFactory) xViewer.getXViewerFactory()).registerAllAttributeColumnsForArtifacts(artifacts, true); |
| } |
| } |
| int total = artifacts.size(); |
| for (int index = 0; index < artifacts.size(); index++) { |
| Artifact artifact = artifacts.get(index); |
| monitor.subTask(String.format("Adding to Table: [%s] [%s of %s]", artifact.getName(), index + 1, total)); |
| |
| DataItem branchItem = getBranchItem(artifact); |
| DataItem scriptItem = getScriptItem(branchItem, artifact); |
| |
| ArtifactItem tempItem = new ArtifactItem(xViewer, artifact, null); |
| |
| DataItem itemFound = scriptItem.getChild(tempItem.getKey()); |
| if (itemFound == null) { |
| scriptItem.addChild(tempItem.getKey(), tempItem); |
| tempItem.setParent(scriptItem); |
| ArtifactTestRunOperator operator = tempItem.getOperator(); |
| if (operator.isFromLocalWorkspace()) { |
| if (operator.isCommitAllowed()) { |
| commitableItems.add(tempItem); |
| } else { |
| uncommitableItems.add(tempItem); |
| } |
| } |
| } |
| monitor.worked(1); |
| } |
| |
| refresh(); |
| } |
| |
| private void refresh() { |
| ensureInitialized(); |
| notifyOnDataChanged(); |
| |
| Displays.ensureInDisplayThread(new Runnable() { |
| @Override |
| public void run() { |
| xViewer.refresh(); |
| }; |
| }); |
| } |
| |
| private DataItem getScriptItem(DataItem branchItem, Artifact artifact) throws OseeCoreException { |
| ArtifactTestRunOperator testRunArtifact = new ArtifactTestRunOperator(artifact); |
| DataItem tempItem = new ScriptItem(testRunArtifact.getScriptUrl(), testRunArtifact.getScriptRevision(), null); |
| DataItem scriptItem = branchItem.getChild(tempItem.getKey()); |
| if (scriptItem == null) { |
| scriptItem = tempItem; |
| scriptItem.setParent(branchItem); |
| branchItem.addChild(scriptItem.getKey(), scriptItem); |
| } |
| return scriptItem; |
| } |
| |
| private DataItem getBranchItem(Artifact artifact) { |
| IOseeBranch branch = artifact.getBranch(); |
| DataItem toReturn = branchMap.get(branch); |
| if (toReturn == null) { |
| toReturn = new BranchItem(branch, null); |
| branchMap.put(branch, toReturn); |
| backingData.add(toReturn); |
| } |
| return toReturn; |
| } |
| |
| private void removeHelper(DataItem item) { |
| if (item != null) { |
| DataItem parent = item.getParent(); |
| if (parent != null) { |
| parent.removeChild(item); |
| if (parent.hasChildren() != true) { |
| removeHelper(parent); |
| parent.dispose(); |
| } |
| } else { |
| branchMap.remove(item.getKey()); |
| backingData.remove(item); |
| } |
| } |
| } |
| |
| public void removeSelected() { |
| List<DataItem> items = getSelected(); |
| for (DataItem item : items) { |
| removeHelper(item); |
| item.dispose(); |
| commitableItems.remove(item); |
| uncommitableItems.remove(item); |
| } |
| refresh(); |
| } |
| |
| public void removeAll() { |
| commitableItems.clear(); |
| uncommitableItems.clear(); |
| for (DataItem dataItem : branchMap.values()) { |
| dataItem.dispose(); |
| } |
| branchMap.clear(); |
| backingData.clear(); |
| refresh(); |
| } |
| |
| public Control getControl() { |
| return xViewer.getTree(); |
| } |
| |
| private List<DataItem> getSelected() { |
| List<DataItem> toReturn = new ArrayList<>(); |
| TreeItem items[] = xViewer.getTree().getSelection(); |
| if (items.length > 0) { |
| for (TreeItem item : items) { |
| toReturn.add((DataItem) item.getData()); |
| } |
| } |
| return toReturn; |
| } |
| |
| public List<Artifact> getSelectedArtifacts() { |
| List<Artifact> toReturn = new ArrayList<>(); |
| for (DataItem item : getSelected()) { |
| Object object = item.getData(); |
| if (object instanceof Artifact) { |
| toReturn.add((Artifact) object); |
| } |
| } |
| return toReturn; |
| } |
| |
| public Artifact[] getUnCommitable() { |
| return getArtifactsFromDataItemList(uncommitableItems); |
| } |
| |
| public Artifact[] getAllCommitable() { |
| return getArtifactsFromDataItemList(commitableItems); |
| } |
| |
| private Artifact[] getArtifactsFromDataItemList(List<DataItem> sourceList) { |
| List<Artifact> toReturn = new ArrayList<>(); |
| for (DataItem item : sourceList) { |
| toReturn.add((Artifact) item.getData()); |
| } |
| return toReturn.toArray(new Artifact[toReturn.size()]); |
| } |
| |
| public Artifact[] getSelectedForCommit() { |
| List<Artifact> toReturn = new ArrayList<>(); |
| for (DataItem item : getSelected()) { |
| if (commitableItems.contains(item)) { |
| toReturn.add((Artifact) item.getData()); |
| } |
| } |
| return toReturn.toArray(new Artifact[toReturn.size()]); |
| } |
| |
| public void removeFromCommitable(final Collection<Artifact> artifacts) { |
| removeArtifactsFromDataItemList(commitableItems, artifacts); |
| removeArtifactsFromDataItemList(uncommitableItems, artifacts); |
| refresh(); |
| } |
| |
| private void removeArtifactsFromDataItemList(List<DataItem> sourceList, final Collection<Artifact> artifactsToRemove) { |
| List<DataItem> itemsToRemove = new ArrayList<>(); |
| for (DataItem item : sourceList) { |
| Object object = item.getData(); |
| if (artifactsToRemove.contains(object)) { |
| itemsToRemove.add(item); |
| } |
| } |
| sourceList.removeAll(itemsToRemove); |
| } |
| |
| private void notifyOnDataChanged() { |
| synchronized (listeners) { |
| for (IDataChangedListener listener : listeners) { |
| listener.onDataChanged(); |
| } |
| } |
| } |
| |
| public void registerListener(IDataChangedListener listener) { |
| synchronized (listeners) { |
| listeners.add(listener); |
| } |
| } |
| |
| public void deRegisterListener(IDataChangedListener listener) { |
| synchronized (listeners) { |
| if (listeners.contains(listener)) { |
| listeners.remove(listener); |
| } |
| } |
| } |
| |
| public boolean isEmpty() { |
| return branchMap.isEmpty(); |
| } |
| } |