core/plugins/org.eclipse.dltk.ui/src/org/eclipse/dltk/ui/browsing/PackagesViewFlatContentProvider.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2017 IBM Corporation and others.
  * 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:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.dltk.ui.browsing;

 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.dltk.core.IModelElement;
 import org.eclipse.dltk.core.IModelElementDelta;
 import org.eclipse.dltk.core.IProjectFragment;
 import org.eclipse.dltk.core.IScriptFolder;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.jface.viewers.IStructuredContentProvider;
 import org.eclipse.jface.viewers.StructuredViewer;
 import org.eclipse.jface.viewers.TableViewer;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;

 /**
  * Table content provider for the hierarchical layout in the packages view.
  * <p>
  * XXX: The standard Java browsing part content provider needs and calls the
  * browsing part/view. This class currently doesn't need to do so but might be
  * required to later.
  * </p>
  */
 class PackagesViewFlatContentProvider extends LogicalPackagesProvider
 		implements IStructuredContentProvider {
 	PackagesViewFlatContentProvider(StructuredViewer viewer) {
 		super(viewer);
 	}

 	/*
 	 * @see
 	 * org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.
 	 * Object)
 	 */
 	public Object[] getChildren(Object parentElement) {

 		if (parentElement instanceof IModelElement) {
 			IModelElement element = (IModelElement) parentElement;

 			int type = element.getElementType();

 			try {
 				switch (type) {
 				case IModelElement.SCRIPT_PROJECT:
 					IScriptProject project = (IScriptProject) element;
 					IScriptFolder[] children = getPackageFragments(
 							project.getScriptFolders());
 					if (isInCompoundState()) {
 						fMapToLogicalPackage.clear();
 						fMapToPackageFragments.clear();
 						return combineSamePackagesIntoLogialPackages(children);
 					} else
 						return children;

 				case IModelElement.PROJECT_FRAGMENT:
 					fMapToLogicalPackage.clear();
 					fMapToPackageFragments.clear();
 					IProjectFragment root = (IProjectFragment) element;
 					return root.getChildren();

 				case IModelElement.SCRIPT_FOLDER:
 					// no children in flat view
 					break;

 				default:
 					// do nothing, empty array returned
 				}
 			} catch (ModelException e) {
 				return NO_CHILDREN;
 			}

 		}
 		return NO_CHILDREN;
 	}

 	/*
 	 * Weeds out packageFragments from external jars
 	 */
 	private IScriptFolder[] getPackageFragments(
 			IScriptFolder[] iPackageFragments) {
 		List<IScriptFolder> list = new ArrayList<>();
 		for (int i = 0; i < iPackageFragments.length; i++) {
 			IScriptFolder fragment = iPackageFragments[i];
 			IModelElement el = fragment.getParent();
 			if (el instanceof IProjectFragment) {
 				IProjectFragment root = (IProjectFragment) el;
 				if (root.isArchive() && root.isExternal())
 					continue;
 			}
 			list.add(fragment);
 		}
 		return list.toArray(new IScriptFolder[list.size()]);
 	}

 	@Override
 	public Object[] getElements(Object inputElement) {
 		return getChildren(inputElement);
 	}

 	@Override
 	protected void processDelta(IModelElementDelta delta)
 			throws ModelException {

 		int kind = delta.getKind();
 		final IModelElement element = delta.getElement();

 		if (isClassPathChange(delta)) {
 			Object input = fViewer.getInput();
 			if (input != null) {
 				if (fInputIsProject
 						&& input.equals(element.getScriptProject())) {
 					postRefresh(input);
 					return;
 				} else if (!fInputIsProject && input.equals(element)) {
 					if (element.exists())
 						postRefresh(input);
 					else
 						postRemove(input);
 					return;
 				}
 			}
 		}

 		if (kind == IModelElementDelta.REMOVED) {
 			Object input = fViewer.getInput();
 			if (input != null && input.equals(element)) {
 				postRemove(input);
 				return;
 			}
 		}

 		if (element instanceof IScriptFolder) {
 			final IScriptFolder frag = (IScriptFolder) element;

 			if (kind == IModelElementDelta.REMOVED) {
 				removeElement(frag);

 			} else if (kind == IModelElementDelta.ADDED) {
 				addElement(frag);

 			} else if (kind == IModelElementDelta.CHANGED) {
 				// just refresh
 				Object toBeRefreshed = element;

 				IScriptFolder pkgFragment = (IScriptFolder) element;
 				LogicalPackage logicalPkg = findLogicalPackage(pkgFragment);
 				// deal with packages that have been filtered and are now
 				// visible
 				if (logicalPkg != null)
 					toBeRefreshed = findElementToRefresh(logicalPkg);
 				else
 					toBeRefreshed = findElementToRefresh(pkgFragment);

 				postRefresh(toBeRefreshed);
 			}
 			// in this view there will be no children of PackageFragment to
 			// refresh
 			return;
 		}
 		processAffectedChildren(delta);
 	}

 	// test to see if element to be refreshed is being filtered out
 	// and if so refresh the viewers input element (JavaProject or
 	// PackageFragmentRoot)
 	private Object findElementToRefresh(IScriptFolder fragment) {
 		if (fViewer.testFindItem(fragment) == null) {
 			if (fInputIsProject)
 				return fragment.getScriptProject();
 			else
 				return fragment.getParent();
 		}
 		return fragment;
 	}

 	// test to see if element to be refreshed is being filtered out
 	// and if so refresh the viewers input element (JavaProject or
 	// PackageFragmentRoot)
 	private Object findElementToRefresh(LogicalPackage logicalPackage) {
 		if (fViewer.testFindItem(logicalPackage) == null) {
 			IScriptFolder fragment = logicalPackage.getScriptFolders()[0];
 			return fragment.getScriptProject();
 		}
 		return logicalPackage;
 	}

 	private void processAffectedChildren(IModelElementDelta delta)
 			throws ModelException {
 		IModelElementDelta[] children = delta.getAffectedChildren();
 		for (int i = 0; i < children.length; i++) {
 			IModelElementDelta elementDelta = children[i];
 			processDelta(elementDelta);
 		}
 	}

 	private void postAdd(final Object child) {
 		postRunnable(() -> {
 			Control ctrl = fViewer.getControl();
 			if (ctrl != null && !ctrl.isDisposed()) {
 				((TableViewer) fViewer).add(child);
 			}
 		});
 	}

 	private void postRemove(final Object object) {
 		postRunnable(() -> {
 			Control ctrl = fViewer.getControl();
 			if (ctrl != null && !ctrl.isDisposed()) {
 				((TableViewer) fViewer).remove(object);
 			}
 		});
 	}

 	private void postRunnable(final Runnable r) {
 		Control ctrl = fViewer.getControl();
 		if (ctrl != null && !ctrl.isDisposed()) {
 			// fBrowsingPart.setProcessSelectionEvents(false);
 			try {
 				Display currentDisplay = Display.getCurrent();
 				if (currentDisplay != null
 						&& currentDisplay.equals(ctrl.getDisplay()))
 					ctrl.getDisplay().syncExec(r);
 				else
 					ctrl.getDisplay().asyncExec(r);
 			} finally {
 				// fBrowsingPart.setProcessSelectionEvents(true);
 			}
 		}
 	}

 	private void removeElement(IScriptFolder frag) {
 		String key = getKey(frag);
 		LogicalPackage lp = (LogicalPackage) fMapToLogicalPackage.get(key);

 		if (lp != null) {
 			lp.remove(frag);
 			// if you need to change the LogicalPackage to a PackageFragment
 			if (lp.getScriptFolders().length == 1) {
 				IScriptFolder fragment = lp.getScriptFolders()[0];
 				fMapToLogicalPackage.remove(key);
 				fMapToPackageFragments.put(key, fragment);

 				// @Improve: Should I replace this with a refresh of the parent?
 				postRemove(lp);
 				postAdd(fragment);
 			}
 			return;
 		} else {
 			fMapToPackageFragments.remove(key);
 			postRemove(frag);
 		}
 	}

 	private void postRefresh(final Object element) {
 		postRunnable(() -> {
 			Control ctrl = fViewer.getControl();
 			if (ctrl != null && !ctrl.isDisposed()) {
 				fViewer.refresh(element);
 			}
 		});
 	}

 	private void addElement(IScriptFolder frag) {
 		String key = getKey(frag);
 		LogicalPackage lp = (LogicalPackage) fMapToLogicalPackage.get(key);

 		if (lp != null && lp.belongs(frag)) {
 			lp.add(frag);
 			return;
 		}

 		IScriptFolder fragment = (IScriptFolder) fMapToPackageFragments
 				.get(key);
 		if (fragment != null) {
 			// must create a new LogicalPackage
 			if (!fragment.equals(frag)) {
 				lp = new LogicalPackage(fragment);
 				lp.add(frag);
 				fMapToLogicalPackage.put(key, lp);

 				// @Improve: should I replace this with a refresh?
 				postRemove(fragment);
 				postAdd(lp);

 				return;
 			}
 		}

 		else {
 			fMapToPackageFragments.put(key, frag);
 			postAdd(frag);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2017 IBM Corporation and others.
	* 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:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.dltk.ui.browsing;

	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.dltk.core.IModelElement;
	import org.eclipse.dltk.core.IModelElementDelta;
	import org.eclipse.dltk.core.IProjectFragment;
	import org.eclipse.dltk.core.IScriptFolder;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.jface.viewers.IStructuredContentProvider;
	import org.eclipse.jface.viewers.StructuredViewer;
	import org.eclipse.jface.viewers.TableViewer;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;

	/**
	* Table content provider for the hierarchical layout in the packages view.
	* <p>
	* XXX: The standard Java browsing part content provider needs and calls the
	* browsing part/view. This class currently doesn't need to do so but might be
	* required to later.
	* </p>
	*/
	class PackagesViewFlatContentProvider extends LogicalPackagesProvider
	implements IStructuredContentProvider {
	PackagesViewFlatContentProvider(StructuredViewer viewer) {
	super(viewer);
	}

	/*
	* @see
	* org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.
	* Object)
	*/
	public Object[] getChildren(Object parentElement) {

	if (parentElement instanceof IModelElement) {
	IModelElement element = (IModelElement) parentElement;

	int type = element.getElementType();

	try {
	switch (type) {
	case IModelElement.SCRIPT_PROJECT:
	IScriptProject project = (IScriptProject) element;
	IScriptFolder[] children = getPackageFragments(
	project.getScriptFolders());
	if (isInCompoundState()) {
	fMapToLogicalPackage.clear();
	fMapToPackageFragments.clear();
	return combineSamePackagesIntoLogialPackages(children);
	} else
	return children;

	case IModelElement.PROJECT_FRAGMENT:
	fMapToLogicalPackage.clear();
	fMapToPackageFragments.clear();
	IProjectFragment root = (IProjectFragment) element;
	return root.getChildren();

	case IModelElement.SCRIPT_FOLDER:
	// no children in flat view
	break;

	default:
	// do nothing, empty array returned
	}
	} catch (ModelException e) {
	return NO_CHILDREN;
	}

	}
	return NO_CHILDREN;
	}

	/*
	* Weeds out packageFragments from external jars
	*/
	private IScriptFolder[] getPackageFragments(
	IScriptFolder[] iPackageFragments) {
	List<IScriptFolder> list = new ArrayList<>();
	for (int i = 0; i < iPackageFragments.length; i++) {
	IScriptFolder fragment = iPackageFragments[i];
	IModelElement el = fragment.getParent();
	if (el instanceof IProjectFragment) {
	IProjectFragment root = (IProjectFragment) el;
	if (root.isArchive() && root.isExternal())
	continue;
	}
	list.add(fragment);
	}
	return list.toArray(new IScriptFolder[list.size()]);
	}

	@Override
	public Object[] getElements(Object inputElement) {
	return getChildren(inputElement);
	}

	@Override
	protected void processDelta(IModelElementDelta delta)
	throws ModelException {

	int kind = delta.getKind();
	final IModelElement element = delta.getElement();

	if (isClassPathChange(delta)) {
	Object input = fViewer.getInput();
	if (input != null) {
	if (fInputIsProject
	&& input.equals(element.getScriptProject())) {
	postRefresh(input);
	return;
	} else if (!fInputIsProject && input.equals(element)) {
	if (element.exists())
	postRefresh(input);
	else
	postRemove(input);
	return;
	}
	}
	}

	if (kind == IModelElementDelta.REMOVED) {
	Object input = fViewer.getInput();
	if (input != null && input.equals(element)) {
	postRemove(input);
	return;
	}
	}

	if (element instanceof IScriptFolder) {
	final IScriptFolder frag = (IScriptFolder) element;

	if (kind == IModelElementDelta.REMOVED) {
	removeElement(frag);

	} else if (kind == IModelElementDelta.ADDED) {
	addElement(frag);

	} else if (kind == IModelElementDelta.CHANGED) {
	// just refresh
	Object toBeRefreshed = element;

	IScriptFolder pkgFragment = (IScriptFolder) element;
	LogicalPackage logicalPkg = findLogicalPackage(pkgFragment);
	// deal with packages that have been filtered and are now
	// visible
	if (logicalPkg != null)
	toBeRefreshed = findElementToRefresh(logicalPkg);
	else
	toBeRefreshed = findElementToRefresh(pkgFragment);

	postRefresh(toBeRefreshed);
	}
	// in this view there will be no children of PackageFragment to
	// refresh
	return;
	}
	processAffectedChildren(delta);
	}

	// test to see if element to be refreshed is being filtered out
	// and if so refresh the viewers input element (JavaProject or
	// PackageFragmentRoot)
	private Object findElementToRefresh(IScriptFolder fragment) {
	if (fViewer.testFindItem(fragment) == null) {
	if (fInputIsProject)
	return fragment.getScriptProject();
	else
	return fragment.getParent();
	}
	return fragment;
	}

	// test to see if element to be refreshed is being filtered out
	// and if so refresh the viewers input element (JavaProject or
	// PackageFragmentRoot)
	private Object findElementToRefresh(LogicalPackage logicalPackage) {
	if (fViewer.testFindItem(logicalPackage) == null) {
	IScriptFolder fragment = logicalPackage.getScriptFolders()[0];
	return fragment.getScriptProject();
	}
	return logicalPackage;
	}

	private void processAffectedChildren(IModelElementDelta delta)
	throws ModelException {
	IModelElementDelta[] children = delta.getAffectedChildren();
	for (int i = 0; i < children.length; i++) {
	IModelElementDelta elementDelta = children[i];
	processDelta(elementDelta);
	}
	}

	private void postAdd(final Object child) {
	postRunnable(() -> {
	Control ctrl = fViewer.getControl();
	if (ctrl != null && !ctrl.isDisposed()) {
	((TableViewer) fViewer).add(child);
	}
	});
	}

	private void postRemove(final Object object) {
	postRunnable(() -> {
	Control ctrl = fViewer.getControl();
	if (ctrl != null && !ctrl.isDisposed()) {
	((TableViewer) fViewer).remove(object);
	}
	});
	}

	private void postRunnable(final Runnable r) {
	Control ctrl = fViewer.getControl();
	if (ctrl != null && !ctrl.isDisposed()) {
	// fBrowsingPart.setProcessSelectionEvents(false);
	try {
	Display currentDisplay = Display.getCurrent();
	if (currentDisplay != null
	&& currentDisplay.equals(ctrl.getDisplay()))
	ctrl.getDisplay().syncExec(r);
	else
	ctrl.getDisplay().asyncExec(r);
	} finally {
	// fBrowsingPart.setProcessSelectionEvents(true);
	}
	}
	}

	private void removeElement(IScriptFolder frag) {
	String key = getKey(frag);
	LogicalPackage lp = (LogicalPackage) fMapToLogicalPackage.get(key);

	if (lp != null) {
	lp.remove(frag);
	// if you need to change the LogicalPackage to a PackageFragment
	if (lp.getScriptFolders().length == 1) {
	IScriptFolder fragment = lp.getScriptFolders()[0];
	fMapToLogicalPackage.remove(key);
	fMapToPackageFragments.put(key, fragment);

	// @Improve: Should I replace this with a refresh of the parent?
	postRemove(lp);
	postAdd(fragment);
	}
	return;
	} else {
	fMapToPackageFragments.remove(key);
	postRemove(frag);
	}
	}

	private void postRefresh(final Object element) {
	postRunnable(() -> {
	Control ctrl = fViewer.getControl();
	if (ctrl != null && !ctrl.isDisposed()) {
	fViewer.refresh(element);
	}
	});
	}

	private void addElement(IScriptFolder frag) {
	String key = getKey(frag);
	LogicalPackage lp = (LogicalPackage) fMapToLogicalPackage.get(key);

	if (lp != null && lp.belongs(frag)) {
	lp.add(frag);
	return;
	}

	IScriptFolder fragment = (IScriptFolder) fMapToPackageFragments
	.get(key);
	if (fragment != null) {
	// must create a new LogicalPackage
	if (!fragment.equals(frag)) {
	lp = new LogicalPackage(fragment);
	lp.add(frag);
	fMapToLogicalPackage.put(key, lp);

	// @Improve: should I replace this with a refresh?
	postRemove(fragment);
	postAdd(lp);

	return;
	}
	}

	else {
	fMapToPackageFragments.put(key, frag);
	postAdd(frag);
	}
	}
	}