| /******************************************************************************* |
| * Copyright (c) 2000, 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 |
| * Jesper Steen Moller - Enhancement 254677 - filter getters/setters |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.debug.ui; |
| |
| import java.util.ArrayList; |
| |
| import org.eclipse.debug.internal.ui.SWTFactory; |
| import org.eclipse.debug.ui.DebugUITools; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.search.SearchEngine; |
| import org.eclipse.jdt.ui.IJavaElementSearchConstants; |
| import org.eclipse.jdt.ui.JavaUI; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferencePage; |
| import org.eclipse.jface.viewers.CheckStateChangedEvent; |
| import org.eclipse.jface.viewers.CheckboxTableViewer; |
| import org.eclipse.jface.viewers.ICheckStateListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.KeyAdapter; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.TableItem; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPreferencePage; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.ElementListSelectionDialog; |
| import org.eclipse.ui.dialogs.SelectionDialog; |
| |
| /** |
| * The preference page for Java step filtering, located at the node Java > Debug > Step Filtering |
| * |
| * @since 3.0 |
| */ |
| public class JavaStepFilterPreferencePage extends PreferencePage implements IWorkbenchPreferencePage { |
| |
| public static final String PAGE_ID = "org.eclipse.jdt.debug.ui.JavaStepFilterPreferencePage"; //$NON-NLS-1$ |
| |
| /** |
| * Content provider for the table. Content consists of instances of StepFilter. |
| * @since 3.2 |
| */ |
| class StepFilterContentProvider implements IStructuredContentProvider { |
| public StepFilterContentProvider() { |
| initTableState(false); |
| } |
| |
| @Override |
| public Object[] getElements(Object inputElement) {return getAllFiltersFromTable();} |
| |
| @Override |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {} |
| |
| @Override |
| public void dispose() {} |
| } |
| |
| //widgets |
| private CheckboxTableViewer fTableViewer; |
| private Button fUseStepFiltersButton; |
| private Button fAddPackageButton; |
| private Button fAddTypeButton; |
| private Button fRemoveFilterButton; |
| private Button fAddFilterButton; |
| private Button fFilterSyntheticButton; |
| private Button fFilterStaticButton; |
| private Button fFilterGetterButton; |
| private Button fFilterSetterButton; |
| private Button fFilterConstructorButton; |
| private Button fStepThruButton; |
| private Button fSelectAllButton; |
| private Button fDeselectAllButton; |
| |
| /** |
| * Constructor |
| */ |
| public JavaStepFilterPreferencePage() { |
| super(); |
| setPreferenceStore(JDIDebugUIPlugin.getDefault().getPreferenceStore()); |
| setTitle(DebugUIMessages.JavaStepFilterPreferencePage_title); |
| setDescription(DebugUIMessages.JavaStepFilterPreferencePage_description); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite) |
| */ |
| @Override |
| protected Control createContents(Composite parent) { |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IJavaDebugHelpContextIds.JAVA_STEP_FILTER_PREFERENCE_PAGE); |
| //The main composite |
| Composite composite = SWTFactory.createComposite(parent, parent.getFont(), 1, 1, GridData.FILL_BOTH, 0, 0); |
| createStepFilterPreferences(composite); |
| return composite; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench) |
| */ |
| @Override |
| public void init(IWorkbench workbench) {} |
| |
| /** |
| * handles the filter button being clicked |
| * @param event the clicked event |
| */ |
| private void handleFilterViewerKeyPress(KeyEvent event) { |
| if (event.character == SWT.DEL && event.stateMask == 0) { |
| removeFilters(); |
| } |
| } |
| |
| /** |
| * Create a group to contain the step filter related widgetry |
| */ |
| private void createStepFilterPreferences(Composite parent) { |
| Composite container = SWTFactory.createComposite(parent, parent.getFont(), 2, 1, GridData.FILL_BOTH, 0, 0); |
| fUseStepFiltersButton = SWTFactory.createCheckButton(container, DebugUIMessages.JavaStepFilterPreferencePage__Use_step_filters, null, DebugUITools.isUseStepFilters(), 2); |
| fUseStepFiltersButton.addSelectionListener(new SelectionListener() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| setPageEnablement(fUseStepFiltersButton.getSelection()); |
| } |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) {} |
| } |
| ); |
| SWTFactory.createLabel(container, DebugUIMessages.JavaStepFilterPreferencePage_Defined_step_fi_lters__8, 2); |
| fTableViewer = CheckboxTableViewer.newCheckList(container, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION); |
| fTableViewer.getTable().setFont(container.getFont()); |
| fTableViewer.setLabelProvider(new FilterLabelProvider()); |
| fTableViewer.setComparator(new FilterViewerComparator()); |
| fTableViewer.setContentProvider(new StepFilterContentProvider()); |
| fTableViewer.setInput(getAllStoredFilters(false)); |
| fTableViewer.getTable().setLayoutData(new GridData(GridData.FILL_BOTH)); |
| fTableViewer.addCheckStateListener(new ICheckStateListener() { |
| @Override |
| public void checkStateChanged(CheckStateChangedEvent event) { |
| ((Filter)event.getElement()).setChecked(event.getChecked()); |
| } |
| }); |
| fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| @Override |
| public void selectionChanged(SelectionChangedEvent event) { |
| ISelection selection = event.getSelection(); |
| if (selection.isEmpty()) { |
| fRemoveFilterButton.setEnabled(false); |
| } else { |
| fRemoveFilterButton.setEnabled(true); |
| } |
| } |
| }); |
| fTableViewer.getControl().addKeyListener(new KeyAdapter() { |
| @Override |
| public void keyPressed(KeyEvent event) { |
| handleFilterViewerKeyPress(event); |
| } |
| }); |
| |
| createStepFilterButtons(container); |
| createStepFilterCheckboxes(container); |
| |
| setPageEnablement(fUseStepFiltersButton.getSelection()); |
| } |
| |
| /** |
| * initializes the checked state of the filters when the dialog opens |
| * @since 3.2 |
| */ |
| private void initTableState(boolean defaults) { |
| Filter[] filters = getAllStoredFilters(defaults); |
| for(int i = 0; i < filters.length; i++) { |
| fTableViewer.add(filters[i]); |
| fTableViewer.setChecked(filters[i], filters[i].isChecked()); |
| } |
| } |
| |
| /** |
| * Enables or disables the widgets on the page, with the |
| * exception of <code>fUseStepFiltersButton</code> according |
| * to the passed boolean |
| * @param enabled the new enablement status of the page's widgets |
| * @since 3.2 |
| */ |
| protected void setPageEnablement(boolean enabled) { |
| fAddFilterButton.setEnabled(enabled); |
| fAddPackageButton.setEnabled(enabled); |
| fAddTypeButton.setEnabled(enabled); |
| fDeselectAllButton.setEnabled(enabled); |
| fSelectAllButton.setEnabled(enabled); |
| fFilterConstructorButton.setEnabled(enabled); |
| fStepThruButton.setEnabled(enabled); |
| fFilterGetterButton.setEnabled(enabled); |
| fFilterSetterButton.setEnabled(enabled); |
| fFilterStaticButton.setEnabled(enabled); |
| fFilterSyntheticButton.setEnabled(enabled); |
| fTableViewer.getTable().setEnabled(enabled); |
| fRemoveFilterButton.setEnabled(enabled & !fTableViewer.getSelection().isEmpty()); |
| } |
| |
| /** |
| * create the checked preferences for the page |
| * @param container the parent container |
| */ |
| private void createStepFilterCheckboxes(Composite container) { |
| fFilterSyntheticButton = SWTFactory.createCheckButton(container, |
| DebugUIMessages.JavaStepFilterPreferencePage_Filter_s_ynthetic_methods__requires_VM_support__17, |
| null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_SYNTHETICS), 2); |
| fFilterStaticButton = SWTFactory.createCheckButton(container, |
| DebugUIMessages.JavaStepFilterPreferencePage_Filter_static__initializers_18, |
| null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_STATIC_INITIALIZERS), 2); |
| fFilterConstructorButton = SWTFactory.createCheckButton(container, |
| DebugUIMessages.JavaStepFilterPreferencePage_Filter_co_nstructors_19, |
| null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_CONSTRUCTORS), 2); |
| fFilterGetterButton = SWTFactory.createCheckButton(container, |
| DebugUIMessages.JavaStepFilterPreferencePage_Filter_getters, |
| null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_GETTERS), 2); |
| fFilterSetterButton = SWTFactory.createCheckButton(container, |
| DebugUIMessages.JavaStepFilterPreferencePage_Filter_setters, |
| null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_SETTERS), 2); |
| fStepThruButton = SWTFactory.createCheckButton(container, |
| DebugUIMessages.JavaStepFilterPreferencePage_0, |
| null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_STEP_THRU_FILTERS), 2); |
| } |
| |
| /** |
| * Creates the button for the step filter options |
| * @param container the parent container |
| */ |
| private void createStepFilterButtons(Composite container) { |
| initializeDialogUnits(container); |
| // button container |
| Composite buttonContainer = new Composite(container, SWT.NONE); |
| GridData gd = new GridData(GridData.FILL_VERTICAL); |
| buttonContainer.setLayoutData(gd); |
| GridLayout buttonLayout = new GridLayout(); |
| buttonLayout.numColumns = 1; |
| buttonLayout.marginHeight = 0; |
| buttonLayout.marginWidth = 0; |
| buttonContainer.setLayout(buttonLayout); |
| //Add filter button |
| fAddFilterButton = SWTFactory.createPushButton(buttonContainer, |
| DebugUIMessages.JavaStepFilterPreferencePage_Add__Filter_9, |
| DebugUIMessages.JavaStepFilterPreferencePage_Key_in_the_name_of_a_new_step_filter_10, null); |
| fAddFilterButton.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event e) { |
| addFilter(); |
| } |
| }); |
| //Add type button |
| fAddTypeButton = SWTFactory.createPushButton(buttonContainer, |
| DebugUIMessages.JavaStepFilterPreferencePage_Add__Type____11, |
| DebugUIMessages.JavaStepFilterPreferencePage_Choose_a_Java_type_and_add_it_to_step_filters_12, null); |
| fAddTypeButton.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event e) { |
| addType(); |
| } |
| }); |
| //Add package button |
| fAddPackageButton = SWTFactory.createPushButton(buttonContainer, |
| DebugUIMessages.JavaStepFilterPreferencePage_Add__Package____13, |
| DebugUIMessages.JavaStepFilterPreferencePage_Choose_a_package_and_add_it_to_step_filters_14, null); |
| fAddPackageButton.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event e) { |
| addPackage(); |
| } |
| }); |
| //Remove button |
| fRemoveFilterButton = SWTFactory.createPushButton(buttonContainer, |
| DebugUIMessages.JavaStepFilterPreferencePage__Remove_15, |
| DebugUIMessages.JavaStepFilterPreferencePage_Remove_all_selected_step_filters_16, |
| null); |
| fRemoveFilterButton.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event e) { |
| removeFilters(); |
| } |
| }); |
| fRemoveFilterButton.setEnabled(false); |
| |
| Label separator= new Label(buttonContainer, SWT.NONE); |
| separator.setVisible(false); |
| gd = new GridData(); |
| gd.horizontalAlignment= GridData.FILL; |
| gd.verticalAlignment= GridData.BEGINNING; |
| gd.heightHint= 4; |
| separator.setLayoutData(gd); |
| //Select All button |
| fSelectAllButton = SWTFactory.createPushButton(buttonContainer, |
| DebugUIMessages.JavaStepFilterPreferencePage__Select_All_1, |
| DebugUIMessages.JavaStepFilterPreferencePage_Selects_all_step_filters_2, null); |
| fSelectAllButton.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event e) { |
| fTableViewer.setAllChecked(true); |
| } |
| }); |
| //De-Select All button |
| fDeselectAllButton = SWTFactory.createPushButton(buttonContainer, |
| DebugUIMessages.JavaStepFilterPreferencePage_Deselect_All_3, |
| DebugUIMessages.JavaStepFilterPreferencePage_Deselects_all_step_filters_4, null); |
| fDeselectAllButton.addListener(SWT.Selection, new Listener() { |
| @Override |
| public void handleEvent(Event e) { |
| fTableViewer.setAllChecked(false); |
| } |
| }); |
| |
| } |
| |
| /** |
| * Allows a new filter to be added to the listing |
| */ |
| private void addFilter() { |
| Filter newfilter = CreateStepFilterDialog.showCreateStepFilterDialog(getShell(), getAllFiltersFromTable()); |
| if (newfilter != null) { |
| fTableViewer.add(newfilter); |
| fTableViewer.setChecked(newfilter, true); |
| fTableViewer.refresh(newfilter); |
| } |
| } |
| |
| /** |
| * add a new type to the listing of available filters |
| */ |
| private void addType() { |
| try { |
| SelectionDialog dialog = JavaUI.createTypeDialog(getShell(), |
| PlatformUI.getWorkbench().getProgressService(), |
| SearchEngine.createWorkspaceScope(), |
| IJavaElementSearchConstants.CONSIDER_CLASSES, |
| false); |
| dialog.setTitle(DebugUIMessages.JavaStepFilterPreferencePage_Add_type_to_step_filters_20); |
| dialog.setMessage(DebugUIMessages.JavaStepFilterPreferencePage_Select_a_type_to_filter_when_stepping_23); |
| if (dialog.open() == IDialogConstants.OK_ID) { |
| Object[] types = dialog.getResult(); |
| if (types != null && types.length > 0) { |
| IType type = (IType)types[0]; |
| addFilter(type.getFullyQualifiedName(), true); |
| } |
| } |
| } |
| catch (JavaModelException jme) { |
| ExceptionHandler.handle(jme, |
| DebugUIMessages.JavaStepFilterPreferencePage_Add_type_to_step_filters_20, |
| DebugUIMessages.JavaStepFilterPreferencePage_Could_not_open_type_selection_dialog_for_step_filters_21); |
| } |
| } |
| |
| /** |
| * add a new package to the list of all available package filters |
| */ |
| private void addPackage() { |
| try { |
| ElementListSelectionDialog dialog = JDIDebugUIPlugin.createAllPackagesDialog(getShell(), null, false); |
| dialog.setTitle(DebugUIMessages.JavaStepFilterPreferencePage_Add_package_to_step_filters_24); |
| dialog.setMessage(DebugUIMessages.JavaStepFilterPreferencePage_Select_a_package_to_filter_when_stepping_27); |
| dialog.setMultipleSelection(true); |
| if (dialog.open() == IDialogConstants.OK_ID) { |
| Object[] packages = dialog.getResult(); |
| if (packages != null) { |
| IJavaElement pkg = null; |
| for (int i = 0; i < packages.length; i++) { |
| pkg = (IJavaElement)packages[i]; |
| String filter = pkg.getElementName() + ".*"; //$NON-NLS-1$ |
| addFilter(filter, true); |
| } |
| } |
| } |
| |
| } |
| catch (JavaModelException jme) { |
| ExceptionHandler.handle(jme, |
| DebugUIMessages.JavaStepFilterPreferencePage_Add_package_to_step_filters_24, |
| DebugUIMessages.JavaStepFilterPreferencePage_Could_not_open_package_selection_dialog_for_step_filters_25); |
| } |
| } |
| |
| /** |
| * Removes the currently selected filters. |
| */ |
| protected void removeFilters() { |
| fTableViewer.remove(((IStructuredSelection)fTableViewer.getSelection()).toArray()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.preference.PreferencePage#performOk() |
| */ |
| @Override |
| public boolean performOk() { |
| DebugUITools.setUseStepFilters(fUseStepFiltersButton.getSelection()); |
| IPreferenceStore store = getPreferenceStore(); |
| ArrayList<String> active = new ArrayList<>(); |
| ArrayList<String> inactive = new ArrayList<>(); |
| String name = ""; //$NON-NLS-1$ |
| Filter[] filters = getAllFiltersFromTable(); |
| for(int i = 0; i < filters.length; i++) { |
| name = filters[i].getName(); |
| if(filters[i].isChecked()) { |
| active.add(name); |
| } |
| else { |
| inactive.add(name); |
| } |
| } |
| String pref = JavaDebugOptionsManager.serializeList(active.toArray(new String[active.size()])); |
| store.setValue(IJDIPreferencesConstants.PREF_ACTIVE_FILTERS_LIST, pref); |
| pref = JavaDebugOptionsManager.serializeList(inactive.toArray(new String[inactive.size()])); |
| store.setValue(IJDIPreferencesConstants.PREF_INACTIVE_FILTERS_LIST, pref); |
| store.setValue(IJDIPreferencesConstants.PREF_FILTER_CONSTRUCTORS, fFilterConstructorButton.getSelection()); |
| store.setValue(IJDIPreferencesConstants.PREF_FILTER_STATIC_INITIALIZERS, fFilterStaticButton.getSelection()); |
| store.setValue(IJDIPreferencesConstants.PREF_FILTER_GETTERS, fFilterGetterButton.getSelection()); |
| store.setValue(IJDIPreferencesConstants.PREF_FILTER_SETTERS, fFilterSetterButton.getSelection()); |
| store.setValue(IJDIPreferencesConstants.PREF_FILTER_SYNTHETICS, fFilterSyntheticButton.getSelection()); |
| store.setValue(IJDIPreferencesConstants.PREF_STEP_THRU_FILTERS, fStepThruButton.getSelection()); |
| return super.performOk(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.preference.PreferencePage#performDefaults() |
| */ |
| @Override |
| protected void performDefaults() { |
| boolean stepenabled = DebugUITools.isUseStepFilters(); |
| fUseStepFiltersButton.setSelection(stepenabled); |
| setPageEnablement(stepenabled); |
| fFilterSyntheticButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_SYNTHETICS)); |
| fFilterStaticButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_STATIC_INITIALIZERS)); |
| fFilterConstructorButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_CONSTRUCTORS)); |
| fFilterGetterButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_GETTERS)); |
| fFilterSetterButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_SETTERS)); |
| fStepThruButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_STEP_THRU_FILTERS)); |
| fTableViewer.getTable().removeAll(); |
| initTableState(true); |
| super.performDefaults(); |
| } |
| |
| /** |
| * adds a single filter to the viewer |
| * @param filter the new filter to add |
| * @param checked the checked state of the new filter |
| * @since 3.2 |
| */ |
| protected void addFilter(String filter, boolean checked) { |
| if(filter != null) { |
| Filter f = new Filter(filter, checked); |
| fTableViewer.add(f); |
| fTableViewer.setChecked(f, checked); |
| } |
| } |
| |
| /** |
| * returns all of the filters from the table, this includes ones that have not yet been saved |
| * @return a possibly empty lits of filters fron the table |
| * @since 3.2 |
| */ |
| protected Filter[] getAllFiltersFromTable() { |
| TableItem[] items = fTableViewer.getTable().getItems(); |
| Filter[] filters = new Filter[items.length]; |
| for(int i = 0; i < items.length; i++) { |
| filters[i] = (Filter)items[i].getData(); |
| filters[i].setChecked(items[i].getChecked()); |
| } |
| return filters; |
| } |
| |
| /** |
| * Returns all of the committed filters |
| * @return an array of committed filters |
| * @since 3.2 |
| */ |
| protected Filter[] getAllStoredFilters(boolean defaults) { |
| Filter[] filters = null; |
| String[] activefilters, inactivefilters; |
| IPreferenceStore store = getPreferenceStore(); |
| if(defaults) { |
| activefilters = JavaDebugOptionsManager.parseList(store.getDefaultString(IJDIPreferencesConstants.PREF_ACTIVE_FILTERS_LIST)); |
| inactivefilters = JavaDebugOptionsManager.parseList(store.getDefaultString(IJDIPreferencesConstants.PREF_INACTIVE_FILTERS_LIST)); |
| } |
| else { |
| activefilters = JavaDebugOptionsManager.parseList(store.getString(IJDIPreferencesConstants.PREF_ACTIVE_FILTERS_LIST)); |
| inactivefilters = JavaDebugOptionsManager.parseList(store.getString(IJDIPreferencesConstants.PREF_INACTIVE_FILTERS_LIST)); |
| } |
| filters = new Filter[activefilters.length + inactivefilters.length]; |
| for(int i = 0; i < activefilters.length; i++) { |
| filters[i] = new Filter(activefilters[i], true); |
| } |
| for(int i = 0; i < inactivefilters.length; i++) { |
| filters[i+activefilters.length] = new Filter(inactivefilters[i], false); |
| } |
| return filters; |
| } |
| } |
