AopReferenceModelNavigatorInterestFilter.java

/*******************************************************************************
 * Copyright (c) 2007, 2011 Spring IDE Developers
 * 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:
 *     Spring IDE Developers - initial API and implementation
 *******************************************************************************/
package org.springframework.ide.eclipse.aop.mylyn.ui;

import org.eclipse.core.resources.IFile;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.mylyn.context.core.AbstractContextStructureBridge;
import org.eclipse.mylyn.context.core.ContextCore;
import org.eclipse.mylyn.context.core.IImplicitlyIntersting;
import org.eclipse.mylyn.context.core.IInteractionElement;
import org.eclipse.mylyn.context.ui.InterestFilter;
import org.eclipse.swt.widgets.Tree;
import org.springframework.ide.eclipse.aop.core.model.IAspectDefinition;
import org.springframework.ide.eclipse.aop.ui.navigator.model.IReferenceNode;
import org.springframework.ide.eclipse.beans.core.internal.model.BeansModelUtils;

/**
 * Extension to the Mylyn {@link InterestFilter} that is used to filter the Spring Aop cross
 * references view.
 * @author Christian Dupuis
 * @author Martin Lippert / Steffen Pingel
 * @since 2.0.1
 */
public class AopReferenceModelNavigatorInterestFilter extends InterestFilter {

	private Object temporarilyUnfiltered = null;

	@Override
	public boolean select(Viewer viewer, Object parent, Object object) {
		try {
			if (!(viewer instanceof StructuredViewer)
					|| !containsMylynInterestFilter((StructuredViewer) viewer)) {
				return true;
			}
			if (isTemporarilyUnfilteredInternal(parent)) {
				return true;
			}
			else if (temporarilyUnfiltered instanceof Tree && isRootElement(object)) {
				return true;
			}

			IInteractionElement element = null;
			if (object instanceof IImplicitlyIntersting) {
				return true;
			}
			else if (object instanceof IInteractionElement) {
				element = (IInteractionElement) object;
			}
			else if (object instanceof IReferenceNode) {
				return isInterestingReferenceParticipant(((IReferenceNode) object));
			}
			if (element != null) {
				return isInteresting(element);
			}
		}
		catch (Throwable t) {
		}
		return false;
	}

	private boolean isInterestingReferenceParticipant(IReferenceNode object) {
		if (object != null) {
			if (object.getReferenceParticipant() != null) {
				Object element = object.getReferenceParticipant();
				if (element instanceof IAspectDefinition) {
					IAspectDefinition def = (IAspectDefinition) element;
					element = BeansModelUtils.getMostSpecificModelElement(def
							.getAspectStartLineNumber(), def.getAspectEndLineNumber(), (IFile) def
							.getResource(), null);
				}
				AbstractContextStructureBridge bridge = ContextCore.getStructureBridge(element);
				if (bridge != null) {
					String handle = bridge.getHandleIdentifier(element);
					IInteractionElement interestElement = ContextCore.getContextManager()
							.getElement(handle);
					if (element != null && isInteresting(interestElement)) {
						return true;
					}
					// TODO CD uncomment this if *really* only interested
					// elements
					// should be displayed
					/*
					 * else { return false; }
					 */
				}
			}
			if (object.getChildren() != null && object.getChildren().length > 0) {
				for (Object child : object.getChildren()) {
					if (child instanceof IReferenceNode) {
						if (isInterestingReferenceParticipant((IReferenceNode) child)) {
							return true;
						}
					}
				}
			}
		}
		return false;
	}

	protected boolean isRootElement(Object object) {
		return object instanceof IReferenceNode;
	}

	protected boolean isInteresting(IInteractionElement element) {
		if (element.getInterest().isPredicted()) {
			return true;
		}
		else {
			return element.getInterest().isInteresting();
		}
	}

	private boolean isTemporarilyUnfilteredInternal(Object parent) {
		if (parent instanceof TreePath) {
			TreePath treePath = (TreePath) parent;
			parent = treePath.getLastSegment();
		}
		return temporarilyUnfiltered != null && temporarilyUnfiltered.equals(parent);
	}

	protected boolean containsMylynInterestFilter(StructuredViewer viewer) {
		for (ViewerFilter filter : viewer.getFilters()) {
			if (filter instanceof InterestFilter) {
				return true;
			}
		}
		return false;
	}

	public void setTemporarilyUnfiltered(Object temprarilyUnfiltered) {
		this.temporarilyUnfiltered = temprarilyUnfiltered;
	}

	/**
	 * @return true if there was an unfiltered node
	 */
	public boolean resetTemporarilyUnfiltered() {
		if (temporarilyUnfiltered != null) {
			this.temporarilyUnfiltered = null;
			return true;
		}
		else {
			return false;
		}
	}

	public Object getTemporarilyUnfiltered() {
		return temporarilyUnfiltered;
	}
}