| /******************************************************************************* |
| * 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 v2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * 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(); |
| } |
| } |
| } |