bundles/org.eclipse.ui.navigator/src/org/eclipse/ui/internal/navigator/NavigatorFilterService.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006, 2015 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.ui.internal.navigator;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.SafeRunner;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
 import org.eclipse.jface.viewers.StructuredSelection;
 import org.eclipse.jface.viewers.StructuredViewer;
 import org.eclipse.jface.viewers.ViewerFilter;
 import org.eclipse.ui.internal.navigator.filters.CommonFilterDescriptor;
 import org.eclipse.ui.internal.navigator.filters.CommonFilterDescriptorManager;
 import org.eclipse.ui.internal.navigator.filters.SkeletonViewerFilter;
 import org.eclipse.ui.navigator.ICommonFilterDescriptor;
 import org.eclipse.ui.navigator.INavigatorFilterService;

 /**
  * @since 3.2
  *
  */
 public class NavigatorFilterService implements INavigatorFilterService {

 	private static final ViewerFilter[] NO_FILTERS = new ViewerFilter[0];

 	private static final String ACTIVATION_KEY = ".filterActivation"; //$NON-NLS-1$

 	private static final String DELIM = ":"; //$NON-NLS-1$

 	private final NavigatorContentService contentService;

 	/* Map of (ICommonFilterDescriptor, ViewerFilter)-pairs */
 	private final Map<ICommonFilterDescriptor, ViewerFilter> declaredViewerFilters = new HashMap<ICommonFilterDescriptor, ViewerFilter>();

 	/* Set of ViewerFilters enforced from visible/active content extensions */
 	private final Set enforcedViewerFilters = new HashSet();

 	/* A set of active filter String ids */
 	private final Set<String> activeFilters = new HashSet<String>();

 	/**
 	 * @param aContentService
 	 *            The corresponding content service
 	 */
 	public NavigatorFilterService(NavigatorContentService aContentService) {
 		contentService = aContentService;
 		restoreFilterActivation();
 	}

 	private synchronized void restoreFilterActivation() {
 		SafeRunner.run(new NavigatorSafeRunnable() {
 			@Override
 			public void run() throws Exception {
 				IEclipsePreferences prefs = NavigatorContentService.getPreferencesRoot();

 				if (prefs.get(getFilterActivationPreferenceKey(), null) != null) {
 					String activatedFiltersPreferenceValue = prefs.get(
 							getFilterActivationPreferenceKey(), null);
 					String[] activeFilterIds = activatedFiltersPreferenceValue.split(DELIM);
 					for (String activeFilterId : activeFilterIds) {
 						activeFilters.add(activeFilterId);
 					}

 				} else {
 					ICommonFilterDescriptor[] visibleFilterDescriptors = getVisibleFilterDescriptors();
 					for (ICommonFilterDescriptor visibleFilterDescriptor : visibleFilterDescriptors) {
 						if (visibleFilterDescriptor.isActiveByDefault()) {
 							activeFilters.add(visibleFilterDescriptor.getId());
 						}
 					}
 				}
 			}
 		});
 	}

 	@Override
 	public void persistFilterActivationState() {

 		synchronized (activeFilters) {
 			CommonFilterDescriptorManager dm = CommonFilterDescriptorManager
 			.getInstance();

 			/*
 			 * by creating a StringBuffer with DELIM, we ensure the string is
 			 * not empty when persisted.
 			 */
 			StringBuffer activatedFiltersPreferenceValue = new StringBuffer(DELIM);

 			for (String id : activeFilters) {
 				if (!dm.getFilterById(id).isVisibleInUi())
 					continue;
 				activatedFiltersPreferenceValue.append(id).append(DELIM);
 			}

 			IEclipsePreferences prefs = NavigatorContentService.getPreferencesRoot();
 			prefs.put(getFilterActivationPreferenceKey(), activatedFiltersPreferenceValue.toString());
 			NavigatorContentService.flushPreferences(prefs);
 		}
 	}

 	/**
 	 * Used for the tests
 	 */
 	public void resetFilterActivationState() {
 		IEclipsePreferences prefs = NavigatorContentService.getPreferencesRoot();
 		prefs.remove(getFilterActivationPreferenceKey());
 		NavigatorContentService.flushPreferences(prefs);
 	}

 	/**
 	 * @return The correct filter activation preference key for the
 	 *         corresponding content service.
 	 */
 	private String getFilterActivationPreferenceKey() {
 		return contentService.getViewerId() + ACTIVATION_KEY;
 	}

 	@Override
 	public ViewerFilter[] getVisibleFilters(boolean toReturnOnlyActiveFilters) {
 		CommonFilterDescriptor[] descriptors = CommonFilterDescriptorManager
 				.getInstance().findVisibleFilters(contentService);

 		List<ViewerFilter> filters = new ArrayList<ViewerFilter>();

 		ViewerFilter instance;
 		for (CommonFilterDescriptor descriptor : descriptors) {
 			if (!toReturnOnlyActiveFilters || isActive(descriptor.getId())) {
 				instance = getViewerFilter(descriptor);
 				if (instance != null) {
 					filters.add(instance);
 				}
 			}
 		}

 		/* return the enforced viewer filters always */
 		filters.addAll(enforcedViewerFilters);

 		if (filters.size() == 0) {
 			return NO_FILTERS;
 		}
 		return filters
 				.toArray(new ViewerFilter[filters.size()]);
 	}

 	/**
 	 * @param descriptor
 	 *            A key into the viewerFilters map.
 	 * @return A non-null ViewerFilter from the extension (or
 	 *         {@link SkeletonViewerFilter#INSTANCE}).
 	 */
 	@Override
 	public ViewerFilter getViewerFilter(ICommonFilterDescriptor descriptor) {
 		ViewerFilter filter = null;
 		synchronized (declaredViewerFilters) {
 			filter = declaredViewerFilters.get(descriptor);
 			if (filter == null) {
 				declaredViewerFilters.put(descriptor,
 						(filter = ((CommonFilterDescriptor) descriptor)
 								.createFilter()));
 			}
 		}
 		return filter;
 	}

 	@Override
 	public ICommonFilterDescriptor[] getVisibleFilterDescriptors() {
 		return CommonFilterDescriptorManager.getInstance().findVisibleFilters(
 				contentService);
 	}

 	/**
 	 * @return the visible filter descriptors for the UI
 	 */
 	public ICommonFilterDescriptor[] getVisibleFilterDescriptorsForUI() {
 		return CommonFilterDescriptorManager.getInstance().findVisibleFilters(
 				contentService, CommonFilterDescriptorManager.FOR_UI);
 	}

 	@Override
 	public boolean isActive(String aFilterId) {
 		synchronized (activeFilters) {
 			return activeFilters.contains(aFilterId);
 		}
 	}

 	@Override
 	public void setActiveFilterIds(String[] theFilterIds) {
 		Assert.isNotNull(theFilterIds);
 		synchronized (activeFilters) {
 			activeFilters.clear();
 			activeFilters.addAll(Arrays.asList(theFilterIds));
 		}
 	}

 	@Override
 	public void activateFilterIdsAndUpdateViewer(String[] filterIdsToActivate) {
 		boolean updateFilterActivation = false;

 		// we sort the array in order to use Array.binarySearch();
 		Arrays.sort(filterIdsToActivate);
 		CommonFilterDescriptor[] visibleFilterDescriptors = (CommonFilterDescriptor[]) getVisibleFilterDescriptors();

 		int indexofFilterIdToBeActivated;

 		List<String> nonUiVisible = null;

 		/* is there a delta? */
 		for (int i = 0; i < visibleFilterDescriptors.length; i++) {
 			indexofFilterIdToBeActivated = Arrays.binarySearch(filterIdsToActivate,
 					visibleFilterDescriptors[i].getId());
 			/*
 			 * Either we have a filter that should be active that isn't XOR a
 			 * filter that shouldn't be active that is currently
 			 */
 			if (indexofFilterIdToBeActivated >= 0 ^ isActive(visibleFilterDescriptors[i].getId())) {
 				updateFilterActivation = true;
 			}

 			// We don't turn of non-UI visible filters here, they have to be manipulated explicitly
 			if (!visibleFilterDescriptors[i].isVisibleInUi()) {
 				if (nonUiVisible == null)
 					nonUiVisible = new ArrayList<String>();
 				nonUiVisible.add(visibleFilterDescriptors[i].getId());
 			}
 		}

 		/* If so, update */
 		if (updateFilterActivation) {
 			if (nonUiVisible != null) {
 				for (String filterIdToActivate : filterIdsToActivate)
 					nonUiVisible.add(filterIdToActivate);
 				filterIdsToActivate = nonUiVisible.toArray(new String[]{});
 			}

 			setActiveFilterIds(filterIdsToActivate);
 			persistFilterActivationState();
 			updateViewer();
 			// the action providers may no longer be enabled, so we
 			// reset the selection.
 			StructuredViewer commonViewer = (StructuredViewer) contentService.getViewer();
 			commonViewer.setSelection(StructuredSelection.EMPTY);
 		}
 	}

 	/**
 	 * Updates the viewer filters to match the active filters.
 	 */
 	public void updateViewer() {
 		StructuredViewer commonViewer = (StructuredViewer) contentService.getViewer();

 		ViewerFilter[] visibleFilters =	getVisibleFilters(true);
 		commonViewer.setFilters(visibleFilters);
 	}

 	/**
 	 * Activate the given array without disabling all other filters.
 	 *
 	 * @param theFilterIds
 	 *            The filter ids to activate.
 	 */
 	public void addActiveFilterIds(String[] theFilterIds) {
 		Assert.isNotNull(theFilterIds);
 		synchronized (activeFilters) {
 			activeFilters.addAll(Arrays.asList(theFilterIds));
 		}
 	}

 	/**
 	 *
 	 * @param aFilterId The id of the filter to activate or deactivate
 	 * @param toMakeActive True to make the filter active, false to make the filter inactive
 	 */
 	public void setActive(String aFilterId, boolean toMakeActive) {

 		synchronized (activeFilters) {
 			boolean isActive = activeFilters.contains(aFilterId);
 			if(isActive ^ toMakeActive) {
 				if(toMakeActive)
 					activeFilters.add(aFilterId);
 				else
 					activeFilters.remove(aFilterId);

 			}

 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2006, 2015 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.ui.internal.navigator;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.SafeRunner;
	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
	import org.eclipse.jface.viewers.StructuredSelection;
	import org.eclipse.jface.viewers.StructuredViewer;
	import org.eclipse.jface.viewers.ViewerFilter;
	import org.eclipse.ui.internal.navigator.filters.CommonFilterDescriptor;
	import org.eclipse.ui.internal.navigator.filters.CommonFilterDescriptorManager;
	import org.eclipse.ui.internal.navigator.filters.SkeletonViewerFilter;
	import org.eclipse.ui.navigator.ICommonFilterDescriptor;
	import org.eclipse.ui.navigator.INavigatorFilterService;

	/**
	* @since 3.2
	*
	*/
	public class NavigatorFilterService implements INavigatorFilterService {

	private static final ViewerFilter[] NO_FILTERS = new ViewerFilter[0];

	private static final String ACTIVATION_KEY = ".filterActivation"; //$NON-NLS-1$

	private static final String DELIM = ":"; //$NON-NLS-1$

	private final NavigatorContentService contentService;

	/* Map of (ICommonFilterDescriptor, ViewerFilter)-pairs */
	private final Map<ICommonFilterDescriptor, ViewerFilter> declaredViewerFilters = new HashMap<ICommonFilterDescriptor, ViewerFilter>();

	/* Set of ViewerFilters enforced from visible/active content extensions */
	private final Set enforcedViewerFilters = new HashSet();

	/* A set of active filter String ids */
	private final Set<String> activeFilters = new HashSet<String>();

	/**
	* @param aContentService
	* The corresponding content service
	*/
	public NavigatorFilterService(NavigatorContentService aContentService) {
	contentService = aContentService;
	restoreFilterActivation();
	}

	private synchronized void restoreFilterActivation() {
	SafeRunner.run(new NavigatorSafeRunnable() {
	@Override
	public void run() throws Exception {
	IEclipsePreferences prefs = NavigatorContentService.getPreferencesRoot();

	if (prefs.get(getFilterActivationPreferenceKey(), null) != null) {
	String activatedFiltersPreferenceValue = prefs.get(
	getFilterActivationPreferenceKey(), null);
	String[] activeFilterIds = activatedFiltersPreferenceValue.split(DELIM);
	for (String activeFilterId : activeFilterIds) {
	activeFilters.add(activeFilterId);
	}

	} else {
	ICommonFilterDescriptor[] visibleFilterDescriptors = getVisibleFilterDescriptors();
	for (ICommonFilterDescriptor visibleFilterDescriptor : visibleFilterDescriptors) {
	if (visibleFilterDescriptor.isActiveByDefault()) {
	activeFilters.add(visibleFilterDescriptor.getId());
	}
	}
	}
	}
	});
	}

	@Override
	public void persistFilterActivationState() {

	synchronized (activeFilters) {
	CommonFilterDescriptorManager dm = CommonFilterDescriptorManager
	.getInstance();

	/*
	* by creating a StringBuffer with DELIM, we ensure the string is
	* not empty when persisted.
	*/
	StringBuffer activatedFiltersPreferenceValue = new StringBuffer(DELIM);

	for (String id : activeFilters) {
	if (!dm.getFilterById(id).isVisibleInUi())
	continue;
	activatedFiltersPreferenceValue.append(id).append(DELIM);
	}

	IEclipsePreferences prefs = NavigatorContentService.getPreferencesRoot();
	prefs.put(getFilterActivationPreferenceKey(), activatedFiltersPreferenceValue.toString());
	NavigatorContentService.flushPreferences(prefs);
	}
	}

	/**
	* Used for the tests
	*/
	public void resetFilterActivationState() {
	IEclipsePreferences prefs = NavigatorContentService.getPreferencesRoot();
	prefs.remove(getFilterActivationPreferenceKey());
	NavigatorContentService.flushPreferences(prefs);
	}

	/**
	* @return The correct filter activation preference key for the
	* corresponding content service.
	*/
	private String getFilterActivationPreferenceKey() {
	return contentService.getViewerId() + ACTIVATION_KEY;
	}

	@Override
	public ViewerFilter[] getVisibleFilters(boolean toReturnOnlyActiveFilters) {
	CommonFilterDescriptor[] descriptors = CommonFilterDescriptorManager
	.getInstance().findVisibleFilters(contentService);

	List<ViewerFilter> filters = new ArrayList<ViewerFilter>();

	ViewerFilter instance;
	for (CommonFilterDescriptor descriptor : descriptors) {
	if (!toReturnOnlyActiveFilters \|\| isActive(descriptor.getId())) {
	instance = getViewerFilter(descriptor);
	if (instance != null) {
	filters.add(instance);
	}
	}
	}

	/* return the enforced viewer filters always */
	filters.addAll(enforcedViewerFilters);

	if (filters.size() == 0) {
	return NO_FILTERS;
	}
	return filters
	.toArray(new ViewerFilter[filters.size()]);
	}

	/**
	* @param descriptor
	* A key into the viewerFilters map.
	* @return A non-null ViewerFilter from the extension (or
	* {@link SkeletonViewerFilter#INSTANCE}).
	*/
	@Override
	public ViewerFilter getViewerFilter(ICommonFilterDescriptor descriptor) {
	ViewerFilter filter = null;
	synchronized (declaredViewerFilters) {
	filter = declaredViewerFilters.get(descriptor);
	if (filter == null) {
	declaredViewerFilters.put(descriptor,
	(filter = ((CommonFilterDescriptor) descriptor)
	.createFilter()));
	}
	}
	return filter;
	}

	@Override
	public ICommonFilterDescriptor[] getVisibleFilterDescriptors() {
	return CommonFilterDescriptorManager.getInstance().findVisibleFilters(
	contentService);
	}

	/**
	* @return the visible filter descriptors for the UI
	*/
	public ICommonFilterDescriptor[] getVisibleFilterDescriptorsForUI() {
	return CommonFilterDescriptorManager.getInstance().findVisibleFilters(
	contentService, CommonFilterDescriptorManager.FOR_UI);
	}

	@Override
	public boolean isActive(String aFilterId) {
	synchronized (activeFilters) {
	return activeFilters.contains(aFilterId);
	}
	}

	@Override
	public void setActiveFilterIds(String[] theFilterIds) {
	Assert.isNotNull(theFilterIds);
	synchronized (activeFilters) {
	activeFilters.clear();
	activeFilters.addAll(Arrays.asList(theFilterIds));
	}
	}

	@Override
	public void activateFilterIdsAndUpdateViewer(String[] filterIdsToActivate) {
	boolean updateFilterActivation = false;

	// we sort the array in order to use Array.binarySearch();
	Arrays.sort(filterIdsToActivate);
	CommonFilterDescriptor[] visibleFilterDescriptors = (CommonFilterDescriptor[]) getVisibleFilterDescriptors();

	int indexofFilterIdToBeActivated;

	List<String> nonUiVisible = null;

	/* is there a delta? */
	for (int i = 0; i < visibleFilterDescriptors.length; i++) {
	indexofFilterIdToBeActivated = Arrays.binarySearch(filterIdsToActivate,
	visibleFilterDescriptors[i].getId());
	/*
	* Either we have a filter that should be active that isn't XOR a
	* filter that shouldn't be active that is currently
	*/
	if (indexofFilterIdToBeActivated >= 0 ^ isActive(visibleFilterDescriptors[i].getId())) {
	updateFilterActivation = true;
	}

	// We don't turn of non-UI visible filters here, they have to be manipulated explicitly
	if (!visibleFilterDescriptors[i].isVisibleInUi()) {
	if (nonUiVisible == null)
	nonUiVisible = new ArrayList<String>();
	nonUiVisible.add(visibleFilterDescriptors[i].getId());
	}
	}

	/* If so, update */
	if (updateFilterActivation) {
	if (nonUiVisible != null) {
	for (String filterIdToActivate : filterIdsToActivate)
	nonUiVisible.add(filterIdToActivate);
	filterIdsToActivate = nonUiVisible.toArray(new String[]{});
	}

	setActiveFilterIds(filterIdsToActivate);
	persistFilterActivationState();
	updateViewer();
	// the action providers may no longer be enabled, so we
	// reset the selection.
	StructuredViewer commonViewer = (StructuredViewer) contentService.getViewer();
	commonViewer.setSelection(StructuredSelection.EMPTY);
	}
	}

	/**
	* Updates the viewer filters to match the active filters.
	*/
	public void updateViewer() {
	StructuredViewer commonViewer = (StructuredViewer) contentService.getViewer();

	ViewerFilter[] visibleFilters = getVisibleFilters(true);
	commonViewer.setFilters(visibleFilters);
	}

	/**
	* Activate the given array without disabling all other filters.
	*
	* @param theFilterIds
	* The filter ids to activate.
	*/
	public void addActiveFilterIds(String[] theFilterIds) {
	Assert.isNotNull(theFilterIds);
	synchronized (activeFilters) {
	activeFilters.addAll(Arrays.asList(theFilterIds));
	}
	}

	/**
	*
	* @param aFilterId The id of the filter to activate or deactivate
	* @param toMakeActive True to make the filter active, false to make the filter inactive
	*/
	public void setActive(String aFilterId, boolean toMakeActive) {

	synchronized (activeFilters) {
	boolean isActive = activeFilters.contains(aFilterId);
	if(isActive ^ toMakeActive) {
	if(toMakeActive)
	activeFilters.add(aFilterId);
	else
	activeFilters.remove(aFilterId);

	}

	}
	}

	}