content: /*******************************************************************************
   * Copyright (c) 2000, 2008 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.wst.jsdt.ui.actions;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.SortedSet;
  import java.util.Stack;
  import java.util.StringTokenizer;
  import java.util.TreeSet;
  
  import org.eclipse.core.runtime.Assert;
  import org.eclipse.jface.action.Action;
  import org.eclipse.jface.action.ContributionItem;
  import org.eclipse.jface.action.GroupMarker;
  import org.eclipse.jface.action.IContributionItem;
  import org.eclipse.jface.action.IMenuListener;
  import org.eclipse.jface.action.IMenuManager;
  import org.eclipse.jface.action.IToolBarManager;
  import org.eclipse.jface.action.Separator;
  import org.eclipse.jface.preference.IPreferenceStore;
  import org.eclipse.jface.viewers.IContentProvider;
  import org.eclipse.jface.viewers.ITreeContentProvider;
  import org.eclipse.jface.viewers.StructuredViewer;
  import org.eclipse.jface.viewers.ViewerFilter;
  import org.eclipse.jface.window.Window;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.events.SelectionAdapter;
  import org.eclipse.swt.events.SelectionEvent;
  import org.eclipse.swt.widgets.Menu;
  import org.eclipse.swt.widgets.MenuItem;
  import org.eclipse.ui.IActionBars;
  import org.eclipse.ui.IMemento;
  import org.eclipse.ui.IViewPart;
  import org.eclipse.ui.actions.ActionGroup;
  import org.eclipse.wst.jsdt.core.IJavaScriptModel;
  import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin;
  import org.eclipse.wst.jsdt.internal.ui.JavaPluginImages;
  import org.eclipse.wst.jsdt.internal.ui.filters.CustomFiltersDialog;
  import org.eclipse.wst.jsdt.internal.ui.filters.FilterDescriptor;
  import org.eclipse.wst.jsdt.internal.ui.filters.FilterMessages;
  import org.eclipse.wst.jsdt.internal.ui.filters.NamePatternFilter;
  
  /**
   * Action group to add the filter action to a view part's tool bar
   * menu.
   * <p>
   * This class may be instantiated; it is not intended to be subclassed.
   * </p>
   * 
   *
   * Provisional API: This class/interface is part of an interim API that is still under development and expected to
   * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
   * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
   * (repeatedly) as the API evolves.
   */
  public class CustomFiltersActionGroup extends ActionGroup {
  
  	private static final String TAG_DUMMY_TO_TEST_EXISTENCE= "TAG_DUMMY_TO_TEST_EXISTENCE"; //$NON-NLS-1$
  
  	class ShowFilterDialogAction extends Action {
  		ShowFilterDialogAction() {
  			setText(FilterMessages.OpenCustomFiltersDialogAction_text); 
  			setImageDescriptor(JavaPluginImages.DESC_ELCL_FILTER);
  			setDisabledImageDescriptor(JavaPluginImages.DESC_DLCL_FILTER);
  		}
  		
  		public void run() {
  			openDialog();
  		}
  	}
  
  	/**
  	 * Menu contribution item which shows and lets check and uncheck filters.
  	 * 
  	 * 
  	 */
  	class FilterActionMenuContributionItem extends ContributionItem {
  
  		private int fItemNumber;
  		private boolean fState;
  		private String fFilterId;
  		private String fFilterName;
  		private CustomFiltersActionGroup fActionGroup;
  
  		/**
  		 * Constructor for FilterActionMenuContributionItem.
  		 * 
  		 * @param actionGroup 	the action group
  		 * @param filterId		the id of the filter
  		 * @param filterName	the name of the filter
  		 * @param state			the initial state of the filter
  		 * @param itemNumber	the menu item index
  		 */
  		public FilterActionMenuContributionItem(CustomFiltersActionGroup actionGroup, String filterId, String filterName, boolean state, int itemNumber) {
  			super(filterId);
  			Assert.isNotNull(actionGroup);
  			Assert.isNotNull(filterId);
  			Assert.isNotNull(filterName);
  			fActionGroup= actionGroup;
  			fFilterId= filterId;
  			fFilterName= filterName;
  			fState= state;
  			fItemNumber= itemNumber;
  		}
  
  		/*
  		 * Overrides method from ContributionItem.
  		 */
  		public void fill(Menu menu, int index) {
  			MenuItem mi= new MenuItem(menu, SWT.CHECK, index);
  			mi.setText("&" + fItemNumber + " " + fFilterName);  //$NON-NLS-1$  //$NON-NLS-2$
  			/*
  			 * XXX: Don't set the image - would look bad because other menu items don't provide image
  			 * XXX: Get working set specific image name from XML - would need to cache icons
  			 */
  //			mi.setImage(JavaPluginImages.get(JavaPluginImages.IMG_OBJS_JAVA_WORKING_SET));
  			mi.setSelection(fState);
  			mi.addSelectionListener(new SelectionAdapter() {
  				public void widgetSelected(SelectionEvent e) {
  					fState= !fState;
  					fActionGroup.setFilter(fFilterId, fState);
  				}
  			});
  		}
  	
  		/*
  		 * @see org.eclipse.jface.action.IContributionItem#isDynamic()
  		 */
  		public boolean isDynamic() {
  			return true;
  		}
  	}
  
  	private static final String TAG_CUSTOM_FILTERS = "customFilters"; //$NON-NLS-1$
  	private static final String TAG_USER_DEFINED_PATTERNS_ENABLED= "userDefinedPatternsEnabled"; //$NON-NLS-1$
  	private static final String TAG_USER_DEFINED_PATTERNS= "userDefinedPatterns"; //$NON-NLS-1$
  	private static final String TAG_XML_DEFINED_FILTERS= "xmlDefinedFilters"; //$NON-NLS-1$
  	private static final String TAG_LRU_FILTERS = "lastRecentlyUsedFilters"; //$NON-NLS-1$
  
  	private static final String TAG_CHILD= "child"; //$NON-NLS-1$
  	private static final String TAG_PATTERN= "pattern"; //$NON-NLS-1$
  	private static final String TAG_FILTER_ID= "filterId"; //$NON-NLS-1$
  	private static final String TAG_IS_ENABLED= "isEnabled"; //$NON-NLS-1$
  
  	private static final String SEPARATOR= ",";  //$NON-NLS-1$
  
  	private static final int MAX_FILTER_MENU_ENTRIES= 3;
  	private static final String RECENT_FILTERS_GROUP_NAME= "recentFiltersGroup"; //$NON-NLS-1$
  	
  	private static class FilterItem {
  		boolean enabled;
  		boolean previouslyEnabled;
  		FilterDescriptor descriptor;
  		String id;
  		
  		private ViewerFilter filterInstance= null;
  		
  		public FilterItem(FilterDescriptor descriptor) {
  			this.descriptor= descriptor;
  			this.id= descriptor.getId();
  			this.previouslyEnabled= false;
  			this.enabled= descriptor.isEnabled();
  		}
  		
  		public ViewerFilter getFilterInstance() {
  			if (filterInstance == null) {
  				filterInstance= descriptor.createViewerFilter();
  			}
  			return filterInstance;
  			
  		}
  	}
  	
  
  	private final StructuredViewer fViewer;
  	private final NamePatternFilter fPatternFilter;
  	
  	private boolean fUserDefinedPatternsEnabled;
  	private String[] fUserDefinedPatterns;
  	
  	private String[] fPreviousPatterns;
  	
  	private final Map/*String, FilterItem*/ fFilterItems;
  
  	/**
  	 * Recently changed filter Ids stack with oldest on top (i.e. at the end).
  	 *
  	 * 
  	 */
  	private Stack fLRUFilterIdsStack; 
  	/**
  	 * Handle to menu manager to dynamically update
  	 * the last recently used filters.
  	 * 
  	 * 
  	 */
  	private IMenuManager fMenuManager;
  	/**
  	 * The menu listener which dynamically updates
  	 * the last recently used filters.
  	 * 
  	 * 
  	 */
  	private IMenuListener fMenuListener;
  	/**
  	 * Filter Ids used in the last view menu invocation.
  	 * 
  	 * 
  	 */
  	private String[] fFilterIdsUsedInLastViewMenu;
  
  	private final String fTargetId;
  	
  	/**
  	 * Creates a new <code>CustomFiltersActionGroup</code>.
  	 * 
  	 * @param part		the view part that owns this action group
  	 * @param viewer	the viewer to be filtered
  	 */
  	public CustomFiltersActionGroup(IViewPart part, StructuredViewer viewer) {
  		this(part.getViewSite().getId(), viewer);
  	}
  
  	/**
  	 * Creates a new <code>CustomFiltersActionGroup</code>.
  	 * 
  	 * @param ownerId	the id of this action group's owner
  	 * @param viewer	the viewer to be filtered
  	 */
  	public CustomFiltersActionGroup(String ownerId, StructuredViewer viewer) {
  		Assert.isNotNull(ownerId);
  		Assert.isNotNull(viewer);
  		fTargetId= ownerId;
  		fViewer= viewer;
  		fPatternFilter= new NamePatternFilter();
  		
  		fLRUFilterIdsStack= new Stack();
  
  		fUserDefinedPatterns= new String[0];
  		fUserDefinedPatternsEnabled= false;
  		fPreviousPatterns= new String[0];
  
  		fFilterItems= new HashMap();
  		FilterDescriptor[] filterDescriptors= FilterDescriptor.getFilterDescriptors(fTargetId);
  		for (int i= 0; i < filterDescriptors.length; i++) {
  			FilterItem item= new FilterItem(filterDescriptors[i]);
  			Object existing= fFilterItems.put(item.id, item);
  			if (existing != null) {
  				JavaScriptPlugin.logErrorMessage("WARNING: Duplicate id for extension-point \"org.eclipse.wst.jsdt.ui.javaElementFilters\" in " + ownerId); //$NON-NLS-1$		
  			}
  		}
  		
  		initializeWithViewDefaults();
  
  		updateViewerFilters();
  	}
  	
  	/*
  	 * Method declared on ActionGroup.
  	 */
  	public void fillActionBars(IActionBars actionBars) {
  		fillToolBar(actionBars.getToolBarManager());
  		fillViewMenu(actionBars.getMenuManager());
  	}
  	
  	/**
  	 * Returns a list of currently enabled filters. The filter
  	 * is identified by its id.
  	 * <p>
  	 * This method is for internal use only and should not
  	 * be called by clients outside of JDT/UI.
  	 * </p>
  	 * 
  	 * @return a list of currently enabled filters
  	 * 
  	 * 
  	 */
  	public String[] internalGetEnabledFilterIds() {
  		ArrayList enabledFilterIds= new ArrayList();
  		for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
  			FilterItem item= (FilterItem) iterator.next();
  			if (item.enabled) {
  				enabledFilterIds.add(item.id);
  			}
  		}
  		return (String[])enabledFilterIds.toArray(new String[enabledFilterIds.size()]);
  	}
  
  	/**
  	 * Removes filters for the given parent and element
  	 * 
  	 * @param parent the parent of the element
  	 * @param element the element
  	 * @param contentProvider the content provider of the viewer from which 
  	 *  the filters will be removed
  	 *  
  	 * @return the array of new filter ids
  	 */
  	public String[] removeFiltersFor(Object parent, Object element, IContentProvider contentProvider) {
  		ArrayList newFilters= new ArrayList();
  		for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
  			FilterItem item= (FilterItem) iterator.next();
  			if (item.enabled) {
  				ViewerFilter filter= item.getFilterInstance();
  	            if (filter != null && isSelected(parent, element, contentProvider, filter))
  	                newFilters.add(item.id);
  			}
  		}
  	    return (String[])newFilters.toArray(new String[newFilters.size()]);
  	}
  	
  	/**
  	 * Sets the filters to the given array of new filters
  	 * 
  	 * @param newFilters the new filters
  	 */
  	public void setFilters(String[] newFilters) {
  	    setEnabledFilterIds(newFilters);
  	    updateViewerFilters();
  	}
  	
  	private boolean isSelected(Object parent, Object element, IContentProvider contentProvider, ViewerFilter filter) {
  	    if (contentProvider instanceof ITreeContentProvider) {
  	        // the element and all its parents have to be selected
  	        ITreeContentProvider provider = (ITreeContentProvider) contentProvider;
  	        while (element != null && !(element instanceof IJavaScriptModel)) {
  	            if (!filter.select(fViewer, parent, element)) 
  	                return false;
  	            element= provider.getParent( element);
  	        }
  	        return true;
  	    } 
  	    return filter.select(fViewer, parent, element);
  	}
  
      /**
  	 * Sets the enable state of the given filter.
  	 * 
  	 * @param filterId the id of the filter
  	 * @param state the filter state
  	 */
  	private void setFilter(String filterId, boolean state) {
  		// Renew filter id in LRU stack
  		fLRUFilterIdsStack.remove(filterId);
  		fLRUFilterIdsStack.add(0, filterId);
  		
  		FilterItem item= (FilterItem) fFilterItems.get(filterId);
  		if (item != null) {
  			item.enabled= state;
  			storeViewDefaults();
  			
  			updateViewerFilters();
  		}
  	}
  		
  	private void setEnabledFilterIds(String[] enabledIds) {
  		// set all to false
  		for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
  			FilterItem item= (FilterItem) iterator.next();
  			item.enabled= false;
  		}
  		// set enabled to true
  		for (int i= 0; i < enabledIds.length; i++) {
  			FilterItem item= (FilterItem) fFilterItems.get(enabledIds[i]);
  			if (item != null) {
  				item.enabled= true;
  			}
  		}
  	}
  
  	private void setUserDefinedPatterns(String[] patterns) {
  		fUserDefinedPatterns= patterns;
  	}
  
  	/**
  	 * Sets the recently changed filters.
  	 * 
  	 * @param changeHistory the change history
  	 * 
  	 */
  	private void setRecentlyChangedFilters(Stack changeHistory) {
  		Stack oldestFirstStack= new Stack();
  		
  		int length= Math.min(changeHistory.size(), MAX_FILTER_MENU_ENTRIES);
  		for (int i= 0; i < length; i++)
  			oldestFirstStack.push(((FilterDescriptor)changeHistory.pop()).getId());
  		
  		length= Math.min(fLRUFilterIdsStack.size(), MAX_FILTER_MENU_ENTRIES - oldestFirstStack.size());
  		int NEWEST= 0;
  		for (int i= 0; i < length; i++) {
  			Object filter= fLRUFilterIdsStack.remove(NEWEST);
  			if (!oldestFirstStack.contains(filter))
  				oldestFirstStack.push(filter);
  		}
  		fLRUFilterIdsStack= oldestFirstStack;
  	}
  	
  	private boolean areUserDefinedPatternsEnabled() {
  		return fUserDefinedPatternsEnabled;
  	}
  
  	private void setUserDefinedPatternsEnabled(boolean state) {
  		fUserDefinedPatternsEnabled= state;
  	}
  
  	private void fillToolBar(IToolBarManager tooBar) {
  	}
  
  	/**
  	 * Fills the given view menu with the entries managed by the
  	 * group.
  	 * 
  	 * @param viewMenu the menu to fill
  	 */
  	public void fillViewMenu(IMenuManager viewMenu) {
  		/*
  		 * Don't change the separator group name.
  		 * Using this name ensures that other filters
  		 * get contributed to the same group.
  		 */
  		viewMenu.add(new Separator("filters")); //$NON-NLS-1$
  		viewMenu.add(new GroupMarker(RECENT_FILTERS_GROUP_NAME));
  		viewMenu.add(new ShowFilterDialogAction());
  
  		fMenuManager= viewMenu;
  		fMenuListener= new IMenuListener() {
  			public void menuAboutToShow(IMenuManager manager) {
  				removePreviousLRUFilterActions(manager);
  				addLRUFilterActions(manager);
  			}
  		};
  		fMenuManager.addMenuListener(fMenuListener);
  	}
  
  	private void removePreviousLRUFilterActions(IMenuManager mm) {
  		if (fFilterIdsUsedInLastViewMenu == null)
  			return;
  		
  		for (int i= 0; i < fFilterIdsUsedInLastViewMenu.length; i++)
  			mm.remove(fFilterIdsUsedInLastViewMenu[i]);
  	}
  
  	private void addLRUFilterActions(IMenuManager mm) {
  		if (fLRUFilterIdsStack.isEmpty()) {
  			fFilterIdsUsedInLastViewMenu= null;
  			return;
  		}
  		
  		SortedSet sortedFilters= new TreeSet(fLRUFilterIdsStack);
  		String[] recentlyChangedFilterIds= (String[])sortedFilters.toArray(new String[sortedFilters.size()]);
  		
  		fFilterIdsUsedInLastViewMenu= new String[recentlyChangedFilterIds.length];
  		for (int i= 0; i < recentlyChangedFilterIds.length; i++) {
  			String id= recentlyChangedFilterIds[i];
  			fFilterIdsUsedInLastViewMenu[i]= id;
  			FilterItem filterItem= (FilterItem) fFilterItems.get(id);
  			if (filterItem != null) {
  				IContributionItem item= new FilterActionMenuContributionItem(this, id, filterItem.descriptor.getName(), filterItem.enabled, i+1);
  				mm.insertBefore(RECENT_FILTERS_GROUP_NAME, item);
  			}
  		}
  	}
  
  	/*
  	 * Method declared on ActionGroup.
  	 */
  	public void dispose() {
  		if (fMenuManager != null)
  			fMenuManager.removeMenuListener(fMenuListener);
  		fFilterItems.clear();
  		super.dispose();
  	}
  	
  	// ---------- viewer filter handling ----------
  	
  	private boolean updateViewerFilters() {
  		ViewerFilter[] installedFilters= fViewer.getFilters();
  		ArrayList viewerFilters= new ArrayList(Arrays.asList(installedFilters));
  		HashSet patterns= new HashSet();
  		
  		boolean hasChange= false;
  		boolean patternChange= false;
  		
  		for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
  			FilterItem item= (FilterItem) iterator.next();
  			if (item.descriptor.isCustomFilter()) {
  				if (item.enabled != item.previouslyEnabled) {
  					ViewerFilter filter= item.getFilterInstance(); // only create when changed
  					if (filter != null) {
  						if (item.enabled) {
  							viewerFilters.add(filter);
  						} else {
  							viewerFilters.remove(filter);
  						}
  						hasChange= true;
  					}
  				}
  			} else if (item.descriptor.isPatternFilter()) {
  				if (item.enabled) {
  					patterns.add(item.descriptor.getPattern());
  				}
  				patternChange |= (item.enabled != item.previouslyEnabled);
  			}
  			item.previouslyEnabled= item.enabled;
  		}
  		
  		if (areUserDefinedPatternsEnabled()) {
  			for (int i= 0; i < fUserDefinedPatterns.length; i++) {
  				patterns.add(fUserDefinedPatterns[i]);
  			}
  		}
  		if (!patternChange) { // no pattern change so far, test if the user patterns made a difference
  			patternChange= hasChanges(patterns, fPreviousPatterns);
  		}
  		
  		fPreviousPatterns= (String[]) patterns.toArray(new String[patterns.size()]);
  		if (patternChange) {
  			fPatternFilter.setPatterns(fPreviousPatterns);
  			if (patterns.isEmpty()) {
  				viewerFilters.remove(fPatternFilter);
  			} else if (!viewerFilters.contains(fPatternFilter)) {
  				viewerFilters.add(fPatternFilter);
  			}
  			hasChange= true;
  		}
  		if (hasChange) {
  			fViewer.setFilters((ViewerFilter[]) viewerFilters.toArray(new ViewerFilter[viewerFilters.size()])); // will refresh
  		}
  		return hasChange;
  	}
  
  	private boolean hasChanges(HashSet patterns, String[] oldPatterns) {
  		HashSet copy= (HashSet) patterns.clone();
  		for (int i= 0; i < oldPatterns.length; i++) {
  			boolean found= copy.remove(oldPatterns[i]);
  			if (!found)
  				return true;
  		}
  		return !copy.isEmpty();
  	}
  
  	// ---------- view kind/defaults persistency ----------
  		
  	private void initializeWithViewDefaults() {
  		// get default values for view
  		IPreferenceStore store= JavaScriptPlugin.getDefault().getPreferenceStore();
  
  		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=22533
  		if (!store.contains(getPreferenceKey(TAG_DUMMY_TO_TEST_EXISTENCE)))
  			return;
  		
  		fUserDefinedPatternsEnabled= store.getBoolean(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED));
  		setUserDefinedPatterns(CustomFiltersDialog.convertFromString(store.getString(getPreferenceKey(TAG_USER_DEFINED_PATTERNS)), SEPARATOR));
  	
  		for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
  			FilterItem item= (FilterItem) iterator.next();
  			String id= item.id;
  			// set default to value from plugin contributions (fixes https://bugs.eclipse.org/bugs/show_bug.cgi?id=73991 ):
  			store.setDefault(id, item.descriptor.isEnabled());
  			item.enabled= store.getBoolean(id);
  		}
  		
  		fLRUFilterIdsStack.clear();
  		String lruFilterIds= store.getString(TAG_LRU_FILTERS);
  		StringTokenizer tokenizer= new StringTokenizer(lruFilterIds, SEPARATOR);
  		while (tokenizer.hasMoreTokens()) {
  			String id= tokenizer.nextToken();
  			if (fFilterItems.containsKey(id) && !fLRUFilterIdsStack.contains(id))
  				fLRUFilterIdsStack.push(id);
  		}
  	}
  
  	private void storeViewDefaults() {
  		// get default values for view
  		IPreferenceStore store= JavaScriptPlugin.getDefault().getPreferenceStore();
  
  		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=22533
  		store.setValue(getPreferenceKey(TAG_DUMMY_TO_TEST_EXISTENCE), "storedViewPreferences");//$NON-NLS-1$
  		
  		store.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED), fUserDefinedPatternsEnabled);
  		store.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS), CustomFiltersDialog.convertToString(fUserDefinedPatterns ,SEPARATOR));
  
  		for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
  			FilterItem item= (FilterItem) iterator.next();
  			store.setValue(item.id, item.enabled);
  		}
  
  		StringBuffer buf= new StringBuffer(fLRUFilterIdsStack.size() * 20);
  		Iterator iter= fLRUFilterIdsStack.iterator();
  		while (iter.hasNext()) {
  			buf.append((String)iter.next());
  			buf.append(SEPARATOR);
  		}
  		store.setValue(TAG_LRU_FILTERS, buf.toString());
  	}
  	
  	private String getPreferenceKey(String tag) {
  		return "CustomFiltersActionGroup." + fTargetId + '.' + tag; //$NON-NLS-1$
  	}
  
  	// ---------- view instance persistency ----------
  
  	/**
  	 * Saves the state of the custom filters in a memento.
  	 * 
  	 * @param memento the memento into which the state is saved
  	 */
  	public void saveState(IMemento memento) {
  		IMemento customFilters= memento.createChild(TAG_CUSTOM_FILTERS);
  		customFilters.putString(TAG_USER_DEFINED_PATTERNS_ENABLED, Boolean.toString(fUserDefinedPatternsEnabled));
  		saveUserDefinedPatterns(customFilters);
  		saveXmlDefinedFilters(customFilters);
  		saveLRUFilters(customFilters);
  	}
  
  	private void saveXmlDefinedFilters(IMemento memento) {
  		IMemento xmlDefinedFilters= memento.createChild(TAG_XML_DEFINED_FILTERS);
  		
  		for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
  			FilterItem item= (FilterItem) iterator.next();
  			
  			IMemento child= xmlDefinedFilters.createChild(TAG_CHILD);
  			child.putString(TAG_FILTER_ID, item.id);
  			child.putString(TAG_IS_ENABLED, String.valueOf(item.enabled));
  		}
  	}
  	/**
  	 * Stores the last recently used filter Ids into
  	 * the given memento
  	 * 
  	 * @param memento the memento into which to store the LRU filter Ids
  	 * 
  	 */
  	private void saveLRUFilters(IMemento memento) {
  		if(fLRUFilterIdsStack != null && !fLRUFilterIdsStack.isEmpty()) {
  			IMemento lruFilters= memento.createChild(TAG_LRU_FILTERS);
  			Iterator iter= fLRUFilterIdsStack.iterator();
  			while (iter.hasNext()) {
  				String id= (String)iter.next();
  				IMemento child= lruFilters.createChild(TAG_CHILD);
  				child.putString(TAG_FILTER_ID, id);
  			}
  		}
  	}
  
  	private void saveUserDefinedPatterns(IMemento memento) {
  		if(fUserDefinedPatterns != null && fUserDefinedPatterns.length > 0) {
  			IMemento userDefinedPatterns= memento.createChild(TAG_USER_DEFINED_PATTERNS);
  			for (int i= 0; i < fUserDefinedPatterns.length; i++) {
  				IMemento child= userDefinedPatterns.createChild(TAG_CHILD);
  				child.putString(TAG_PATTERN, fUserDefinedPatterns[i]);
  			}
  		}
  	}
  
  	/**
  	 * Restores the state of the filter actions from a memento.
  	 * <p>
  	 * Note: This method does not refresh the viewer.
  	 * </p>
  	 * 
  	 * @param memento the memento from which the state is restored
  	 */	
  	public void restoreState(IMemento memento) {
  		if (memento == null)
  			return;
  		IMemento customFilters= memento.getChild(TAG_CUSTOM_FILTERS);
  		if (customFilters == null)
  			return;
  		String userDefinedPatternsEnabled= customFilters.getString(TAG_USER_DEFINED_PATTERNS_ENABLED);
  		if (userDefinedPatternsEnabled == null)
  			return;
  
  		fUserDefinedPatternsEnabled= Boolean.valueOf(userDefinedPatternsEnabled).booleanValue();
  		restoreUserDefinedPatterns(customFilters);
  		restoreXmlDefinedFilters(customFilters);
  		restoreLRUFilters(customFilters);
  		
  		updateViewerFilters();
  	}
  
  	private void restoreUserDefinedPatterns(IMemento memento) {
  		IMemento userDefinedPatterns= memento.getChild(TAG_USER_DEFINED_PATTERNS);
  		if(userDefinedPatterns != null) {	
  			IMemento children[]= userDefinedPatterns.getChildren(TAG_CHILD);
  			String[] patterns= new String[children.length];
  			for (int i = 0; i < children.length; i++)
  				patterns[i]= children[i].getString(TAG_PATTERN);
  
  			setUserDefinedPatterns(patterns);
  		} else
  			setUserDefinedPatterns(new String[0]);
  	}
  
  	private void restoreXmlDefinedFilters(IMemento memento) {
  		IMemento xmlDefinedFilters= memento.getChild(TAG_XML_DEFINED_FILTERS);
  		if(xmlDefinedFilters != null) {
  			IMemento[] children= xmlDefinedFilters.getChildren(TAG_CHILD);
  			for (int i= 0; i < children.length; i++) {
  				String id= children[i].getString(TAG_FILTER_ID);
  				Boolean isEnabled= Boolean.valueOf(children[i].getString(TAG_IS_ENABLED));
  				FilterItem item= (FilterItem) fFilterItems.get(id);
  				if (item != null) {
  					item.enabled= isEnabled.booleanValue();
  				}
  			}
  		}
  	}
  
  	private void restoreLRUFilters(IMemento memento) {
  		IMemento lruFilters= memento.getChild(TAG_LRU_FILTERS);
  		fLRUFilterIdsStack.clear();
  		if(lruFilters != null) {
  			IMemento[] children= lruFilters.getChildren(TAG_CHILD);
  			for (int i= 0; i < children.length; i++) {
  				String id= children[i].getString(TAG_FILTER_ID);
  				if (fFilterItems.containsKey(id) && !fLRUFilterIdsStack.contains(id))
  					fLRUFilterIdsStack.push(id);
  			}
  		}
  	}
  	
  	// ---------- dialog related code ----------
  
  	private void openDialog() {
  		CustomFiltersDialog dialog= new CustomFiltersDialog(
  			fViewer.getControl().getShell(),
  			fTargetId,
  			areUserDefinedPatternsEnabled(),
  			fUserDefinedPatterns,
  			internalGetEnabledFilterIds());
  		
  		if (dialog.open() == Window.OK) {
  			setEnabledFilterIds(dialog.getEnabledFilterIds());
  			setUserDefinedPatternsEnabled(dialog.areUserDefinedPatternsEnabled());
  			setUserDefinedPatterns(dialog.getUserDefinedPatterns());
  			setRecentlyChangedFilters(dialog.getFilterDescriptorChangeHistory());
  
  			storeViewDefaults();
  
  			updateViewerFilters();
  		}
  	}
  }
  