core/plugins/org.eclipse.dltk.ui/src/org/eclipse/dltk/ui/viewsupport/ProblemTreeViewer.java

/*******************************************************************************
 * Copyright (c) 2000, 2017 IBM Corporation and others.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 * 
 * SPDX-License-Identifier: EPL-2.0
 *
 *******************************************************************************/
package org.eclipse.dltk.ui.viewsupport;

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

import org.eclipse.core.resources.IResource;
import org.eclipse.dltk.core.IMember;
import org.eclipse.dltk.internal.ui.IWorkingCopyProvider;
import org.eclipse.dltk.ui.ProblemsLabelDecorator.ProblemsLabelChangedEvent;
import org.eclipse.jface.viewers.IBaseLabelProvider;
import org.eclipse.jface.viewers.LabelProviderChangedEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.Widget;

/**
 * Extends a TreeViewer to allow more performance when showing error ticks. A
 * <code>ProblemItemMapper</code> is contained that maps all items in the tree
 * to underlying resource
 */
public class ProblemTreeViewer extends TreeViewer implements
		ResourceToItemsMapper.IContentViewerAccessor {

	protected ResourceToItemsMapper fResourceToItemsMapper;

	public ProblemTreeViewer(Composite parent) {
		super(parent);
		initMapper();
	}

	public ProblemTreeViewer(Composite parent, int style) {
		super(parent, style);
		initMapper();
	}

	public ProblemTreeViewer(Tree tree) {
		super(tree);
		initMapper();
	}

	@Override
	public void doUpdateItem(Widget item) {
		doUpdateItem(item, item.getData(), true);
	}

	private void initMapper() {
		fResourceToItemsMapper = new ResourceToItemsMapper(this);
	}

	@Override
	protected void mapElement(Object element, Widget item) {
		super.mapElement(element, item);
		if (item instanceof Item) {
			fResourceToItemsMapper.addToMap(element, (Item) item);
		}
	}

	@Override
	protected void unmapElement(Object element, Widget item) {
		if (item instanceof Item) {
			fResourceToItemsMapper.removeFromMap(element, (Item) item);
		}
		super.unmapElement(element, item);
	}

	@Override
	protected void unmapAllElements() {
		fResourceToItemsMapper.clearMap();
		super.unmapAllElements();
	}

	@Override
	protected void handleLabelProviderChanged(LabelProviderChangedEvent event) {
		if (event instanceof ProblemsLabelChangedEvent) {
			ProblemsLabelChangedEvent e = (ProblemsLabelChangedEvent) event;
			if (!e.isMarkerChange() && canIgnoreChangesFromAnnotionModel()) {
				return;
			}
		}
		Object[] changed = addAditionalProblemParents(event.getElements());

		if (changed != null && !fResourceToItemsMapper.isEmpty()) {
			ArrayList others = new ArrayList();
			for (int i = 0; i < changed.length; i++) {
				Object curr = changed[i];
				if (curr instanceof IResource) {
					fResourceToItemsMapper.resourceChanged((IResource) curr);
				} else {
					others.add(curr);
				}
			}
			if (others.isEmpty()) {
				return;
			}
			event = new LabelProviderChangedEvent(
					(IBaseLabelProvider) event.getSource(), others.toArray());
		} else {
			// we have modified the list of changed elements via add additional
			// parents.
			if (event.getElements() != changed)
				event = new LabelProviderChangedEvent(
						(IBaseLabelProvider) event.getSource(), changed);
		}
		super.handleLabelProviderChanged(event);
	}

	/**
	 * Answers whether this viewer can ignore label provider changes resulting
	 * from marker changes in annotation models
	 */
	private boolean canIgnoreChangesFromAnnotionModel() {
		Object contentProvider = getContentProvider();
		return contentProvider instanceof IWorkingCopyProvider
				&& !((IWorkingCopyProvider) contentProvider)
						.providesWorkingCopies();
	}

	/**
	 * Decides if {@link #isExpandable(Object)} should also test filters. The
	 * default behaviour is to do this only for IMembers. Implementors can
	 * replace this behaviour.
	 *
	 * @param parent
	 *            the given element
	 * @return returns if if {@link #isExpandable(Object)} should also test
	 *         filters for the given element.
	 */
	protected boolean evaluateExpandableWithFilters(Object parent) {
		return parent instanceof IMember;
	}

	@Override
	public boolean isExpandable(Object parent) {
		if (hasFilters() && evaluateExpandableWithFilters(parent)) {
			// workaround for 65762
			Object[] children = getRawChildren(parent);
			if (children.length > 0) {
				ViewerFilter[] filters = getFilters();
				for (int i = 0; i < children.length; i++) {
					if (!isFiltered(children[i], parent, filters)) {
						return true;
					}
				}
			}
			return false;
		}
		return super.isExpandable(parent);
	}

	/**
	 * method to test if a element has any children that passed the filters
	 *
	 * @param parent
	 *            the element to test
	 * @return return <code>true</code> if the element has at least a child that
	 *         passed the filters
	 */
	protected final boolean hasFilteredChildren(Object parent) {
		Object[] rawChildren = getRawChildren(parent);
		return containsNonFiltered(rawChildren, parent);
	}

	@Override
	protected Object[] getFilteredChildren(Object parent) {
		return filter(getRawChildren(parent), parent);
	}

	private Object[] filter(Object[] elements, Object parent) {
		if (!hasFilters() || elements.length == 0) {
			return elements;
		}
		List list = new ArrayList(elements.length);
		ViewerFilter[] filters = getFilters();
		for (int i = 0; i < elements.length; i++) {
			Object object = elements[i];
			if (!isFiltered(object, parent, filters)) {
				list.add(object);
			}
		}
		return list.toArray();
	}

	private boolean containsNonFiltered(Object[] elements, Object parent) {
		if (elements.length == 0) {
			return false;
		}
		if (!hasFilters()) {
			return true;
		}
		ViewerFilter[] filters = getFilters();
		for (int i = 0; i < elements.length; i++) {
			Object object = elements[i];
			if (!isFiltered(object, parent, filters)) {
				return true;
			}
		}
		return false;
	}

	@Override
	protected final Object[] filter(Object[] elements) {
		return filter(elements, getRoot());
	}

	/**
	 * All element filter tests must go through this method. Can be overridden
	 * by subclasses.
	 *
	 * @param object
	 *            the object to filter
	 * @param parent
	 *            the parent
	 * @param filters
	 *            the filters to apply
	 * @return true if the element is filtered
	 */
	protected boolean isFiltered(Object object, Object parent,
			ViewerFilter[] filters) {
		for (int i = 0; i < filters.length; i++) {
			ViewerFilter filter = filters[i];
			if (!filter.select(this, parent, object))
				return true;
		}
		return false;
	}

	protected Object[] addAditionalProblemParents(Object[] elements) {
		return elements;
	}

}