flowexportwizardselectionmanager.java

一个java写的business process management系统

/*
 * Copyright (c) 2003, Alexander Greif
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Flow4J-Eclipse project nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

package net.orthanc.flow4j.designer.ui.wizards;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import net.orthanc.flow4j.designer.core.Flow4JPlugin;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Tree;

/**
 * @author alex
 *
 * TODO
 * 
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class FlowExportWizardSelectionManager {

	private CheckboxTreeViewer treeViewer;
	private CheckboxTableViewer listViewer;

	private TreeCheckStateListener treeCheckStateListener =
		new TreeCheckStateListener();
	private ListCheckStateListener listCheckStateListener =
		new ListCheckStateListener();

	private TreeSelectionChangedListener treeSelectionChangedListener =
		new TreeSelectionChangedListener();

	//	private IBaseLabelProvider treeLabelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
	//	private IBaseLabelProvider listLabelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
	private IBaseLabelProvider treeLabelProvider = new LabelProvider();
	private IBaseLabelProvider listLabelProvider = new LabelProvider();

	private TreeContentProvider treeContentProvider = new TreeContentProvider();
	private ListContentProvider listContentProvider = new ListContentProvider();

	private Object currentTreeSelection;

	private FlowCheckTree flowTree;

	/**
	 * TODO
	 * @param composite
	 */
	FlowExportWizardSelectionManager() {
		createFlowCheckTree();
	}

	/**
	 * 
	 * TODO
	 *
	 */
	private void createFlowCheckTree() {
		flowTree = new FlowCheckTree(null, null);
		try {
			IJavaProject[] jprojects =
				JavaCore
					.create(Flow4JPlugin.getWorkspaceRoot())
					.getJavaProjects();
			for (int i = 0; i < jprojects.length; i++) {
				IJavaProject javaProject = jprojects[i];
				IPackageFragment[] els = javaProject.getPackageFragments();
				for (int j = 0; j < els.length; j++) {
					IPackageFragment packageFragment =
						(IPackageFragment) els[j];
					Object[] nonJavaResources =
						packageFragment.getNonJavaResources();
					for (int k = 0; k < nonJavaResources.length; k++) {
						Object obj = nonJavaResources[k];
						if (!(obj instanceof IFile))
							continue;
						IFile nonJavaResource = (IFile) obj;
						if (Flow4JPlugin.isFlowFile(nonJavaResource)) {
							Path namePath =
								new Path(
									javaProject.getElementName()
										+ "/"
										+ packageFragment.getElementName()
										+ "/"
										+ nonJavaResource.getName());
							List underlyingObjectPath = new ArrayList();
							underlyingObjectPath.add(javaProject);
							underlyingObjectPath.add(packageFragment);
							underlyingObjectPath.add(nonJavaResource);
							flowTree.store(namePath, underlyingObjectPath);
						}
					}
				}
			}
		} catch (JavaModelException e) {
			Flow4JPlugin.log(e);
		}
	}

	public FlowCheckTree getFlowCheckTree() {
		return flowTree;
	}

	/**
	 * 
	 * TODO
	 * @param parent
	 */
	void createContents(Composite parent, int width, int height) {
		GridData gridData = new GridData();
		gridData.horizontalSpan = 6;
		Label label = new Label(parent, SWT.NONE);
		label.setText("Select the flows to export:");
		label.setLayoutData(gridData);

		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 2;
		layout.makeColumnsEqualWidth = true;
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));

		createTreeViewer(composite, width / 2, height);
		createListViewer(composite, width / 2, height);

		//treeViewer.setInput(Flow4JPlugin.getWorkspaceRoot());
		treeViewer.setInput(flowTree);
	}

	/**
	 *	Creates this group's tree viewer.
	 */
	protected void createTreeViewer(Composite parent, int width, int height) {
		Tree tree = new Tree(parent, SWT.CHECK | SWT.BORDER);
		GridData data = new GridData(GridData.FILL_BOTH);
		data.widthHint = width;
		data.heightHint = height;
		tree.setLayoutData(data);

		treeViewer = new CheckboxTreeViewer(tree);
		treeViewer.setUseHashlookup(true);
		treeViewer.setContentProvider(treeContentProvider);
		treeViewer.setLabelProvider(treeLabelProvider);
		//treeViewer.addTreeListener(this);
		treeViewer.addCheckStateListener(treeCheckStateListener);
		treeViewer.addSelectionChangedListener(treeSelectionChangedListener);
	}

	/**
	 *	Creates this group's list viewer.
	 */
	protected void createListViewer(Composite parent, int width, int height) {
		listViewer = CheckboxTableViewer.newCheckList(parent, SWT.BORDER);
		listViewer.setUseHashlookup(true);
		GridData data = new GridData(GridData.FILL_BOTH);
		data.widthHint = width;
		data.heightHint = height;
		listViewer.getTable().setLayoutData(data);
		listViewer.setContentProvider(listContentProvider);
		listViewer.setLabelProvider(listLabelProvider);
		listViewer.addCheckStateListener(listCheckStateListener);
	}

	/**
	 * 
	 * @author alex
	 *
	 * TODO
	 * 
	 * To change the template for this generated type comment go to
	 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
	 */
	private class TreeCheckStateListener implements ICheckStateListener {

		/**
		* @see org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged(org.eclipse.jface.viewers.CheckStateChangedEvent)
		*/
		public void checkStateChanged(CheckStateChangedEvent event) {
			Object checkedElem = event.getElement();
			flowTree.setChecked(
				((FlowCheckTree) checkedElem).getPath(),
				event.getChecked());
		}
	}

	/**
	 * 
	 * @author alex
	 *
	 * TODO
	 * 
	 * To change the template for this generated type comment go to
	 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
	 */
	private class ListCheckStateListener implements ICheckStateListener {

		/**
		* @see org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged(org.eclipse.jface.viewers.CheckStateChangedEvent)
		*/
		public void checkStateChanged(CheckStateChangedEvent event) {
			Object checkedElem = event.getElement();
			flowTree.setChecked(
				((FlowCheckItem) checkedElem).getPath(),
				event.getChecked());
		}
	}

	/**
	 * @author alex
	 *
	 * TODO
	 * 
	 * To change the template for this generated type comment go to
	 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
	 */
	private class TreeSelectionChangedListener
		implements ISelectionChangedListener {
		FlowExportWizardSelectionManager selectionManager;

		/* (non-Javadoc)
		* @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
		*/
		public void selectionChanged(final SelectionChangedEvent event) {
			BusyIndicator
				.showWhile(
					listViewer.getTable().getShell().getDisplay(),
					new Runnable() {
				public void run() {
					IStructuredSelection selection =
						(IStructuredSelection) event.getSelection();
					Object selectedElement = selection.getFirstElement();
					//					if (selectedElement == null) {
					//						currentTreeSelection = null;
					//						listViewer.setInput(null);
					//						return;
					//					}
					populateListViewer(selectedElement);
				}
			});
		}
	}

	/**
	 *Sets the contents of the list viewer based upon the specified selected
	 *tree element.  This also includes checking the appropriate list items.
	 *
	 *@param treeElement java.lang.Object
	 */
	protected void populateListViewer(final Object treeElement) {
		if (treeElement == currentTreeSelection)
			return;
		currentTreeSelection = treeElement;

		if (treeElement == null) {
			listViewer.setInput(null);
			return;
		}

		/*String path = "";
		if (treeElement instanceof IJavaProject) {
			IJavaProject javaProject = (IJavaProject)treeElement;
			path = javaProject.getElementName();
		} else if (treeElement instanceof IPackageFragment) {
			IJavaElement elem = (IJavaElement)treeElement;
			IJavaProject javaProject = elem.getJavaProject();
			path = javaProject.getElementName() + "/" + elem.getElementName();
		}
		
		FlowCheckTree input = flowTree.getBranch(new Path(path));*/
		FlowCheckTree input =
			flowTree.getBranch(((FlowCheckTree) treeElement).getPath());
		listViewer.setInput(input);
		if (input.items != null)
			for (Iterator iter = input.items.iterator(); iter.hasNext();) {
				FlowCheckItem item = (FlowCheckItem) iter.next();
				listViewer.setChecked(item, item.isChecked);
				//listViewer.setChecked(item.underlyingObject, item.isChecked);
			}

		//		List listItemsToCheck= (List) fCheckedStateStore.get(treeElement);
		//
		//		if (listItemsToCheck != null) {
		//			Iterator listItemsEnum= listItemsToCheck.iterator();
		//			while (listItemsEnum.hasNext())
		//				fListViewer.setChecked(listItemsEnum.next(), true);
		//		}
	}

	/**
	 * @author alex
	 *
	 * TODO
	 * 
	 * To change the template for this generated type comment go to
	 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
	 */
	private class TreeContentProvider implements ITreeContentProvider {

		/**
		 * @see ITreeContentProvider#getChildren(Object)
		 */
		public Object[] getChildren(Object parentElement) {
			/*if (parentElement instanceof IJavaProject) {
				IJavaProject project = (IJavaProject)parentElement;
				//	all packages are side by side under the project
				return ((FlowCheckTree)flowTree.branches.get(project.getElementName())).getUndelyingTreeChildren();
			}
			return new Object[0];*/
			FlowCheckTree parent = (FlowCheckTree) parentElement;
			return parent.branches == null
				? new Object[0]
				: parent.branches.values().toArray();
		}

		/**
		 * @see IStructuredContentProvider#getElements(Object)