Attachment #121923 for bug #215361

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 215361
Collapse All | Expand All




    <apidef name="refactoring">Refactoring API</apidef>
</apidefs>
<changes>
    <change id="RefactoringResultsFilters">
        <api name="refactoring"/>
        <summary>Added an API to support filters of the Find Usages results.</summary>
        <version major="1" minor="29"/>
        <date day="10" month="7" year="2012"/>
        <author login="ralphbenjamin"/>
        <compatibility addition="yes"/>
        <description>
            <p>
                This API allows refactoring plugins to add/enable filters to the
                results window and refactoring elements to specify if they should
                be included in the results.
            </p>
        </description>
        <class package="org.netbeans.modules.refactoring.api" name="AbstractRefactoring"/>
        <class package="org.netbeans.modules.refactoring.api" name="RefactoringElement"/>
        <class package="org.netbeans.modules.refactoring.api" name="RefactoringSession"/>
        <class package="org.netbeans.modules.refactoring.spi" name="FiltersManager"/>
        <class package="org.netbeans.modules.refactoring.spi.ui" name="FiltersDescription"/>
        <issue number="215361"/>
    </change>
    <change id="FinishSession">
        <api name="refactoring"/>
        <summary>Changed access level of #finish() to public.</summary>

Lines 4-8 Link Here

(-)a/refactoring.api/nbproject/project.properties (-1 / +1 lines)
4	javadoc.apichanges=${basedir}/apichanges.xml	4	javadoc.apichanges=${basedir}/apichanges.xml
5	javadoc.title=Refactoring API	5	javadoc.title=Refactoring API
6		6
7	spec.version.base=1.28.0	7	spec.version.base=1.29.0
8	test.config.stableBTD.includes=*/Test.class	8	test.config.stableBTD.includes=*/Test.class




import org.netbeans.modules.refactoring.api.impl.APIAccessor;
import org.netbeans.modules.refactoring.api.impl.ProgressSupport;
import org.netbeans.modules.refactoring.api.impl.SPIAccessor;
import org.netbeans.modules.refactoring.spi.FiltersManager;
import org.netbeans.modules.refactoring.spi.GuardedBlockHandler;
import org.netbeans.modules.refactoring.spi.GuardedBlockHandlerFactory;
import org.netbeans.modules.refactoring.spi.ProgressProvider;
import org.netbeans.modules.refactoring.spi.ReadOnlyFilesHandler;
import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;
import org.netbeans.modules.refactoring.spi.RefactoringPlugin;
import org.netbeans.modules.refactoring.spi.RefactoringPluginFactory;
import org.netbeans.modules.refactoring.spi.impl.RefactoringPanel;
import org.netbeans.modules.refactoring.spi.impl.Util;
import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;
import org.netbeans.modules.refactoring.spi.ui.FiltersDescription.Provider;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.modules.ModuleInfo;
import org.openide.util.Lookup;
import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;
import org.netbeans.modules.refactoring.spi.impl.RefactoringPanel;
import org.openide.modules.Modules;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.Parameters;
import org.openide.util.lookup.InstanceContent;

    private static final int PLUGIN_STEPS = 30;
    
    private ArrayList plugins;
    private FiltersDescription filtersDescription;
    
    ArrayList pluginsWithProgress;
    

        if (plugins == null) {
            plugins = new ArrayList();
            // get plugins from the lookup
            filtersDescription = new FiltersDescription();
            Lookup.Result result = Lookup.getDefault().lookup(new Lookup.Template(RefactoringPluginFactory.class));
            for (Iterator it = result.allInstances().iterator(); it.hasNext();) {
                RefactoringPluginFactory factory = (RefactoringPluginFactory) it.next();

                        //  SafeDeleteRefactoringPlugin.
                        //  #65980
                        plugins.add(plugin);
                        if(plugin instanceof FiltersDescription.Provider) {
                            FiltersDescription.Provider prov = (FiltersDescription.Provider) plugin;
                            prov.addFilters(filtersDescription);
                        }
                    }
                }
            }
        }
        return plugins;
    }

    /**
     * The FiltersDescription used for this refactoring.
     *
     * @return the FiltersDescription
     * @since 1.29
     * @see FiltersManager
     */
    public @CheckForNull FiltersDescription getFiltersDescription() {
        return filtersDescription;
    }
    
    Collection getGBHandlers() {
        if (gbHandlers == null) {

            } catch (Throwable t) {
                problem =createProblemAndLog(problem, t, plugin.getClass());
            }
            if (problem!=null && problem.isFatal()) {
                return problem;
            } else if(plugin instanceof FiltersDescription.Provider) {
                Provider provider = (Provider) plugin;
                provider.enableFilters(filtersDescription);
            }
        }
        
        //TODO: 

Lines 44-52 Link Here

(-)a/refactoring.api/src/org/netbeans/modules/refactoring/api/RefactoringElement.java (-2 / +15 lines)
44	package org.netbeans.modules.refactoring.api;	44	package org.netbeans.modules.refactoring.api;
45		45
46	import org.netbeans.api.annotations.common.NonNull;	46	import org.netbeans.api.annotations.common.NonNull;
		47	import org.netbeans.modules.refactoring.spi.FiltersManager;
		48	import org.netbeans.modules.refactoring.spi.FiltersManager.Filterable;
47	import org.netbeans.modules.refactoring.spi.RefactoringElementImplementation;	49	import org.netbeans.modules.refactoring.spi.RefactoringElementImplementation;
48	import org.netbeans.modules.refactoring.spi.ui.TreeElement;	50	import org.netbeans.modules.refactoring.spi.ui.TreeElement;
49	import org.netbeans.modules.refactoring.spi.ui.TreeElementFactory;
50	import org.openide.filesystems.FileObject;	51	import org.openide.filesystems.FileObject;
51	import org.openide.text.PositionBounds;	52	import org.openide.text.PositionBounds;
52	import org.openide.util.Lookup;	53	import org.openide.util.Lookup;
Lines 180-184 Link Here
180	return hash;	181	return hash;
181	}	182	}
182		183
183		184	/**
		185	* Indicates if this element should be included in the results.
		186	* @param filtersManager the FiltersManager to use
		187	* @return true if this element should be included
		188	* @since 1.29
		189	*/
		190	public boolean include(FiltersManager filtersManager) {
		191	if(impl instanceof FiltersManager.Filterable) {
		192	Filterable filterable = (Filterable) impl;
		193	return filterable.filter(filtersManager);
		194	}
		195	return true;
		196	}
184	}	197	}




    }
    
    /**
     * Indicates if this session is finished.
     * @return true if this session is finished, false otherwise
     * @see #finished()
     * @since 1.29
     */
    public boolean isFinished() {
        return finished.get();
    }
    
    /**
     *  Adds progress listener to this RefactoringSession
     * @param listener to add
     */




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.refactoring.spi;

import org.netbeans.modules.refactoring.api.RefactoringElement;
import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;

/**
 * Handles creation and manipulation with boolean state filters.
 *
 * @author Ralph Benjamin Ruijs <ralphbenjamin@netbeans.org>
 * @see FiltersDescription
 * @since 1.29
 */
public abstract class FiltersManager {

    /**
     * Indicates if a filter is selected.
     *
     * @param filterName the name of the filter to check
     * @return Returns true when given filter is selected, false otherwise.
     */
    public abstract boolean isSelected(String filterName);

    /**
     * {@code RefactoringElement}s should implement this interface if they
     * should be filterable in the results.
     *
     * @see RefactoringElement#include
     */
    public static interface Filterable {

        /**
         * Indicates if this element should be included in the results.
         *
         * @param manager the FiltersManager to use
         * @return true if this element should be included
         */
        boolean filter(FiltersManager manager);
    }
}




 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */
package org.netbeans.modules.refactoring.spi.impl;
package org.netbeans.modules.java.navigation.base;

import java.awt.Dimension;
import java.awt.Insets;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.prefs.Preferences;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.Icon;
import javax.swing.JComponent;
import javax.swing.JToggleButton;
import javax.swing.JToolBar;
import javax.swing.SwingUtilities;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ChangeEvent;
import org.netbeans.modules.refactoring.spi.FiltersManager;
import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;
import org.openide.util.Mutex;
import org.openide.util.NbPreferences;

/**
 * Handles creation and manipulation with boolean state filters.
 *
 * @author Dafe Simomek
 */
public final class FiltersManagerImpl extends FiltersManager {

    private FiltersComponent comp;

    static FiltersManagerImpl create(FiltersDescription descr) {
        return new FiltersManagerImpl(descr);
    }

    /**
     * Indicates if a filter is selected.
     *
     * @param filterName the name of the filter to check
     * @return Returns true when given filter is selected, false otherwise.
     */
    @Override
    public boolean isSelected(String filterName) {
        return comp.isSelected(filterName);
    }

    /**
     * Sets boolean value of filter with given name. True means filter is
     * selected (enabled), false otherwise. Note, must be called from AWT
     * thread.
     */
    public void setSelected(String filterName, boolean value) {
        comp.setFilterSelected(filterName, value);
    }

    /**
     * @return component instance visually representing filters
     */
    public JToolBar getComponent(JToggleButton... additionalButtons) {
        if(additionalButtons != null && additionalButtons.length > 0) {
            comp.addAdditionalButtons(additionalButtons);
        }
        return comp.toolbar;
    }

    /**
     * @return Filters description
     */
    public FiltersDescription getDescription() {
        return comp.getDescription();
    }

    /**
     * Assigns listener for listening to filter changes
     */
    public void hookChangeListener(FilterChangeListener l) {
        comp.hookFilterChangeListener(l);
    }

    /**
     * Interface for listening to changes of filter states contained in
     * FIltersPanel
     */
    public interface FilterChangeListener {

        /**
         * Called whenever some changes in state of filters contained in filters
         * panel is triggered
         */
        public void filterStateChanged(ChangeEvent e);
        
    } // end of FilterChangeListener
    

    /**
     * Private, creation managed by factory method 'create'
     */
    private FiltersManagerImpl(FiltersDescription descr) {
        comp = new FiltersComponent(descr);
    }

    /**
     * Swing component representing filters in panel filled with toggle buttons.
     * Provides thread safe access to the states of filters by copying states
     * into private map, properly sync'ed.
     */
    private class FiltersComponent implements ActionListener {

        /**
         * list of <JToggleButton> visually representing filters
         */
        private List<JToggleButton> toggles;
        /**
         * description of filters
         */
        private final FiltersDescription filtersDesc;
        /**
         * lock for listener
         */
        private final Object L_LOCK = new Object();
        /**
         * listener
         */
        private FilterChangeListener clientL;
        /**
         * lock for map of filter states
         */
        private final Object STATES_LOCK = new Object();
        /**
         * copy of filter states for accessing outside AWT
         */
        private Map<String, Boolean> filterStates;
        private JToolBar toolbar;

        /**
         * Returns selected state of given filter, thread safe.
         */
        public boolean isSelected(String filterName) {
            Boolean result;
            synchronized (STATES_LOCK) {
                if (filterStates == null) {

                }
                result = filterStates.get(filterName);
            }

            if (result == null) {
                throw new IllegalArgumentException("Filter " + filterName + " not found.");
            }
            return result.booleanValue();
        }

        /**
         * Sets filter value, AWT only
         */
        public void setFilterSelected(String filterName, boolean value) {
            assert SwingUtilities.isEventDispatchThread();

            int index = filterIndexForName(filterName);
            if (index < 0) {
                throw new IllegalArgumentException("Filter " + filterName + " not found.");

            // notify
            fireChange();
        }

        public void hookFilterChangeListener(FilterChangeListener l) {
            synchronized (L_LOCK) {
                clientL = l;
            }
        }

        public FiltersDescription getDescription() {
            return filtersDesc;
        }

        /**
         * Not public, instances created using factory method createPanel
         */
        FiltersComponent(FiltersDescription descr) {
            super(BoxLayout.X_AXIS);
            this.filtersDesc = descr;
            // always create swing content in AWT thread
            Mutex.EVENT.readAccess(new Runnable() {
                @Override
                public void run() {
                    initPanel();
                }
            });
        }

        /**
         * Called only from AWT
         */
        private void initPanel() {
            // configure toolbar
            toolbar = new JToolBar(JToolBar.VERTICAL);
            toolbar.setFloatable(false);
            toolbar.setRollover(true);
            toolbar.setBorderPainted(true);
            toolbar.setBorder(
                    javax.swing.BorderFactory.createCompoundBorder(
                    javax.swing.BorderFactory.createMatteBorder(0, 1, 0, 0,
                    javax.swing.UIManager.getDefaults().getColor("Separator.foreground")), //NOI18N
                    javax.swing.BorderFactory.createEmptyBorder(0, 1, 0, 0)));
            toolbar.setOpaque(false);
            toolbar.setFocusable(false);
            // create toggle buttons
            int filterCount = filtersDesc.getFilterCount();
            toggles = new ArrayList<JToggleButton>(filterCount);
            JToggleButton toggleButton;

            Map<String, Boolean> fStates = new HashMap<String, Boolean>(filterCount * 2);

            for (int i = 0; i < filterCount; i++) {
                toggleButton = createToggle(fStates, i);
                toggles.add(toggleButton);
            }

            // add toggle buttons
            JToggleButton curToggle;
            for (int i = 0; i < toggles.size(); i++) {
                curToggle = toggles.get(i);
                curToggle.addActionListener(this);
                toolbar.add(curToggle);
                if (i != toggles.size() - 1) {
                    toolbar.add(new Space());
                }
            }

            add(toolbar);
            
            // initialize member states map
            synchronized (STATES_LOCK) {
                filterStates = fStates;
            }
        }

        private void addAdditionalButtons(JToggleButton[] sortButtons) {
            Dimension space = new Dimension(3, 0);
            for (JToggleButton button : sortButtons) {
                Dimension size = new Dimension(21, 21); // 3 less than other buttons
                button.setMaximumSize(size);
                button.setMinimumSize(size);
                button.setPreferredSize(size);
//                button.setMargin(new Insets(2, 3, 2, 3));
                toolbar.addSeparator(space);
                toolbar.add(button);
            }
        }

        private JToggleButton createToggle(Map<String, Boolean> fStates, int index) {
            boolean isSelected = filtersDesc.isSelected(index);
            Icon icon = filtersDesc.getIcon(index);
        
        private JToggleButton createToggle (Map<String,Boolean> fStates, int index) {
            boolean isSelected = getPreferences().getBoolean( filtersDesc.getName(index), filtersDesc.isSelected(index) );
            Icon icon = filtersDesc.getSelectedIcon(index);
            // ensure small size, just for the icon
            JToggleButton result = new JToggleButton(icon, isSelected);
            Dimension size = new Dimension(21, 21); // 3 less than other buttons
            result.setMaximumSize(size);
            result.setMinimumSize(size);
            result.setPreferredSize(size);
            result.setBorderPainted(false);
//            result.setMargin(new Insets(2, 3, 2, 3));
            result.setToolTipText(filtersDesc.getTooltip(index));
            result.setEnabled(filtersDesc.isEnabled(index));
            fStates.put(filtersDesc.getKey(index), Boolean.valueOf(isSelected));

            
            return result;
        }

        /**
         * Finds and returns index of filter with given name or -1 if no such
         * filter exists.
         */
        private int filterIndexForName(String filterName) {
            int filterCount = filtersDesc.getFilterCount();
            String curName;
            for (int i = 0; i < filterCount; i++) {
                curName = filtersDesc.getKey(i);
                if (filterName.equals(curName)) {
                    return i;
                }

            return -1;
        }

        /**
         * Reactions to toggle button click,
         */
        @Override
        public void actionPerformed(ActionEvent e) {
            // copy changed state first
            JToggleButton toggle = (JToggleButton) e.getSource();
            int index = toggles.indexOf(e.getSource());
            synchronized (STATES_LOCK) {
                filterStates.put(filtersDesc.getKey(index),
                        Boolean.valueOf(toggle.isSelected()));
            }
            // notify
            fireChange();
        }

        private void fireChange() {
            FilterChangeListener lCopy;
            synchronized (L_LOCK) {
                // no listener = no notification

                }
                lCopy = clientL;
            }

            // notify listener
            lCopy.filterStateChanged(new ChangeEvent(FiltersManagerImpl.this));
        }

        @Override
        public void removeNotify() {
            //remember filter settings
            if( null != filterStates ) {
                Preferences prefs = getPreferences();
                for( String filterName : filterStates.keySet() ) {
                    prefs.putBoolean( filterName, filterStates.get( filterName ) );
                }
            }
            super.removeNotify();
        }
    
    } // end of FiltersComponent

    private static class Space extends JComponent {

        private static final Dimension SPACE = new Dimension(3, 3);

        @Override
        public Dimension getPreferredSize() {
            return getMinimumSize();
        }
        @Override
        public Dimension getMaximumSize() {
            return getMinimumSize();
        }
        @Override
        public Dimension getMinimumSize() {
            return SPACE;
        }
    }
    
}




import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.Map.Entry;
import java.util.prefs.Preferences;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.text.html.HTMLEditorKit;
import javax.swing.text.html.parser.ParserDelegator;
import javax.swing.tree.DefaultTreeModel;

import org.netbeans.api.project.*;
import org.netbeans.modules.parsing.api.indexing.IndexingManager;
import org.netbeans.modules.refactoring.api.*;
import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;
import org.netbeans.modules.refactoring.spi.ui.RefactoringCustomUI;
import org.netbeans.modules.refactoring.spi.ui.RefactoringUI;
import org.netbeans.modules.refactoring.spi.ui.TreeElement;

import org.openide.awt.Mnemonics;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;
import org.openide.text.CloneableEditorSupport;
import org.openide.text.PositionBounds;
import org.openide.util.*;
import org.openide.windows.TopComponent;


 *
 * @author  Pavel Flaska, Martin Matula
 */
public class RefactoringPanel extends JPanel implements FiltersManagerImpl.FilterChangeListener {
    private static final RequestProcessor RP = new RequestProcessor(RefactoringPanel.class.getName(), 1, false, false);
    
    // PRIVATE FIELDS

    private transient JButton refreshButton = null;
    /* button lying in the toolbar allows expansion of all nodes in a tree */
    private transient JToggleButton expandButton = null;
    private JToolBar toolBar = null;

    private transient JButton refactorButton = null;
    private transient JButton cancelButton = null;

    private transient boolean isVisible = false;
    private transient RefactoringSession session = null;
    private transient ParametersPanel parametersPanel = null;
    private transient JScrollPane scrollPane = null;
    private transient JPanel southPanel;
    public JSplitPane splitPane;
    private JPanel left;

    private Component customComponent;
    private AtomicBoolean cancelRequest = new AtomicBoolean();
    private int size = 0;


    
    static Image PACKAGE_BADGE = ImageUtilities.loadImage( "org/netbeans/spi/java/project/support/ui/packageBadge.gif" ); // NOI18N
    private FiltersManagerImpl filtersManager;
    private JComponent filterBar;
    private JPanel toolbars;
    
    public RefactoringPanel(RefactoringUI ui) {
        this(ui,null);
    }
    
    public RefactoringPanel(RefactoringUI ui, TopComponent caller) {
        if (caller!=null) {
            refCallerTC = new WeakReference<TopComponent>(caller);
        }
        this.ui = ui;
        this.isQuery = ui.isQuery();
        if (isQuery) {

            ui.getRefactoring().addProgressListener(fuListener = new FUListener());
        }
        initialize();
        updateFilters();
        refresh(false);
    }
    

    
    /* initializes all the ui */
    private void initialize() {
        if (inited) {
            return ;
        }
        checkEventThread();
        setFocusCycleRoot(true);
        splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);

        splitPane.setBorder(null);
        // add panel with buttons
        JButton[] buttons = getButtons();
        // there will be at least one button on panel
        southPanel = new JPanel(new GridBagLayout());
        for (int i = 0; i < buttons.length; i++) {
            for (int i = 0; i < buttons.length; i++) {
                GridBagConstraints c = new GridBagConstraints();
                c.gridy = 0;
                c.insets = new Insets(5, 5, 5, 0);
                southPanel.add(buttons[i], c);
            }
            JPanel pp = new JPanel(new BorderLayout());
            GridBagConstraints c = new GridBagConstraints();
            c.gridy = 0;
            c.insets = new Insets(5, 5, 5, 0);
            southPanel.add(buttons[i], c);
        }
        JPanel pp = new JPanel(new BorderLayout());
        GridBagConstraints c = new GridBagConstraints();
        c.gridy = 0;
        c.insets = new Insets(5, 5, 5, 5);
        c.weightx = 1;
        c.fill = GridBagConstraints.HORIZONTAL;
        southPanel.add(pp, c);

        if (!isQuery|| callback != null) {
            left.add(southPanel, BorderLayout.SOUTH);
        }
        if ("Aqua".equals(UIManager.getLookAndFeel().getID())) { //NOI18N
            southPanel.setBackground(UIManager.getColor("NbExplorerView.background"));
        }
        // put the toolbar to the panel. If the getToolBar() returns null,
        // suppose the toolbar does not exist.
        JToolBar toolbar = getToolBar();
        if (toolbar != null) {
            if ("Aqua".equals(UIManager.getLookAndFeel().getID())) { //NOI18N
                toolbar.setBackground(UIManager.getColor("NbExplorerView.background"));
            }
            toolbars = new JPanel(new BorderLayout());
            toolbars.add(toolbar, BorderLayout.WEST);
            left.add(toolbars, BorderLayout.WEST);
        }
        if (toolBar != null)
            left.add(toolBar, BorderLayout.WEST);
        validate();
        inited=true;
    }

        );
        expandButton.setBorderPainted(false);
        expandButton.addActionListener(getButtonListener());
        // create toolbar
        toolBar = new JToolBar(JToolBar.VERTICAL);
        toolBar.setFloatable(false); 
        
        logicalViewButton = new JToggleButton(
            ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/api/resources/logical_view.png", false));

        stopButton.setBorderPainted(false);
        stopButton.addActionListener(getButtonListener());
        
        // create toolbar
        JToolBar toolbar = new JToolBar(JToolBar.VERTICAL);
        toolbar.setFloatable(false);

        toolbar.add(refreshButton);
        toolbar.add(stopButton);
        toolbar.add(prevMatch);
        toolbar.add(nextMatch);
        toolbar.add(logicalViewButton);
        toolbar.add(physicalViewButton);
        toolbar.add(expandButton);
        if (ui instanceof RefactoringCustomUI) {
            toolbar.add(customViewButton);
        }
        return toolbar;
        
        return toolBar;
    }
    
    /**

     * if you want to provide any other buttons with different action to be 
     * performed.
     *
     * @return  array of available buttons.
     */
    private JButton[] getButtons() {
        checkEventThread();


    void switchToLogicalView() {
        logicalViewButton.setSelected(true);
        if (currentView == LOGICAL) {
            return ;
        }
        currentView = LOGICAL;
        physicalViewButton.setSelected(false);
        if (customViewButton!=null) {

    
    void switchToPhysicalView() {
        physicalViewButton.setSelected(true);
        if (currentView == PHYSICAL) {
            return ;
        }
        currentView = PHYSICAL;
        logicalViewButton.setSelected(false);
        if (customViewButton!=null) {


    void switchToCustomView() {
        customViewButton.setSelected(true);
        if (currentView == GRAPHICAL) {
            return ;
        }
        currentView = GRAPHICAL;
        logicalViewButton.setSelected(false);
        physicalViewButton.setSelected(false);

        return node;
    }
    
    private static final String getString(String key) {
        return NbBundle.getMessage(RefactoringPanel.class, key);
    }
    
    /**
     * Overrides default ExplorerPanel behaviour. Does nothing now.
     */
    protected void updateTitle() {
    }
    
    /**
     * Method is responsible for making changes in sources.
     */

     * This is the reason of lazy initialization.
     */
    private ButtonL getButtonListener() {
        if (buttonListener == null) {
            buttonListener = new ButtonL();
        }
        
        return buttonListener;
    }

        final RefactoringPanelContainer cont = isQuery ? RefactoringPanelContainer.getUsagesComponent() : RefactoringPanelContainer.getRefactoringComponent();
        cont.makeBusy(true);
        initialize();
        if(showParametersPanel) {
            updateFilters();
        }

        cancelRequest.set(false);
        stopButton.setVisible(isQuery && showParametersPanel);
        refreshButton.setVisible(!isQuery || !showParametersPanel);
        stopButton.setEnabled(showParametersPanel);
        final String description = ui.getDescription();
        setToolTipText("<html>" + description + "</html>"); // NOI18N
        final Collection<RefactoringElement> elements = session.getRefactoringElements();
        setName(ui.getName());
        if (ui instanceof RefactoringCustomUI) {
            if (customComponent==null) {
                customComponent = ((RefactoringCustomUI) ui).getCustomComponent(elements);
            }
            this.left.remove(customComponent);
        }
        final ProgressHandle progressHandle = ProgressHandleFactory.createHandle(NbBundle.getMessage(RefactoringPanel.class, isQuery ? "LBL_PreparingUsagesTree":"LBL_PreparingRefactoringTree"));

            RP.post(new Runnable() {
                @Override
                public void run() {
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            setTreeControlsEnabled(false);
                        }
                    });
                    Set<FileObject> fileObjects = new HashSet<FileObject>();
                    int errorsNum = 0;
                    if (!isQuery) {

                            }
                        }
                    }
                    StringBuffer errorsDesc = getErrorDesc(errorsNum, isQuery?size:elements.size(), 0);
                    final CheckNode root = new CheckNode(ui, description + errorsDesc.toString() + "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;",ImageUtilities.loadImageIcon("org/netbeans/modules/refactoring/api/resources/" + (isQuery ? "findusages.png" : "refactoring.gif"), false), isQuery);
                    final Map<Object, CheckNode> nodes = new HashMap<Object, CheckNode>();
                    

                    }

                    int i=0;
                    int hidden = 0;
                    try {
                        //[retouche]                    JavaModel.getJavaRepository().beginTrans(false);
                        try {
                            // ui.getRefactoring().setClassPath();
                            for (Iterator it = elements.iterator(); it.hasNext();i++) {
                                final RefactoringElement e = (RefactoringElement) it.next();
                                if(e.include(filtersManager)) {
                                    createNode(TreeElementFactory.getTreeElement(e), nodes, root);
                                } else {
                                    hidden++;
                                }
                                if (isQuery && showParametersPanel) {
                                    if (cancelRequest.get()) {
                                        break;


                                    final boolean last = !it.hasNext();
                                    final int occurrences = i + 1;
                                    final int hiddenOccurrences = hidden;
                                    size = occurrences;
                                    if ((occurrences % 10 == 0 && !session.isFinished()) || last) {
                                        SwingUtilities.invokeLater(new Runnable() {

                                            @Override
                                            public void run() {
                                                root.setNodeLabel(description + getErrorDesc(0, occurrences, hiddenOccurrences));
                                                if (last) {
                                                    tree.repaint();
                                                }

                                        });
                                    }
                                }
//                                PositionBounds pb = e.getPosition();
                                fileObjects.add(e.getParentFile());
                                
                                if (!isQuery) {

                    } finally {
                        progressHandle.finish();
                        cont.makeBusy(false);
                        setTreeControlsEnabled(true);
                        SwingUtilities.invokeLater(new Runnable() {
                            @Override
                            public void run() {
                                setTreeControlsEnabled(true);
                                stopButton.setEnabled(false);
                                stopButton.setVisible(false);
                                refreshButton.setVisible(true);
                                if(showParametersPanel) {
                                    updateFilters();
                                }
                            }
                        });
                    }
                    
                    if (!(isQuery && showParametersPanel)) {
                        root.setNodeLabel(description + getErrorDesc(errorsNum, isQuery?size:elements.size(), hidden).toString());
                        setupTree(root, showParametersPanel, elements.size());
                    }
                    
                }

                private StringBuffer getErrorDesc(int errorsNum, int occurencesNum, int hiddenNum) throws MissingResourceException {
                    StringBuffer errorsDesc = new StringBuffer();
                    errorsDesc.append(" [").append(occurencesNum); // NOI18N
                    errorsDesc.append(' ');

                            );
                        errorsDesc.append("</font>"); // NOI18N
                    }
                    if (hiddenNum > 0) {
                        errorsDesc.append(',');
                        errorsDesc.append(' ');
                        errorsDesc.append("<font color=#CC0000>").append(hiddenNum); // NOI18N
                        errorsDesc.append(' ');
                        errorsDesc.append(NbBundle.getMessage(RefactoringPanel.class, "LBL_Hidden"));
                        errorsDesc.append("</font>"); // NOI18N
                    }
                    errorsDesc.append(']');
                    return errorsDesc;
                }

            cont.addPanel(this);
            isVisible = true;
        }
        if (!isQuery) {
            setRefactoringEnabled(false, true);
        }
    }
    
    private void setTreeControlsEnabled(final boolean b) {
        expandButton.setEnabled(b);
        logicalViewButton.setEnabled(b);
        physicalViewButton.setEnabled(b);
        if (customViewButton != null) {
            customViewButton.setEnabled(b);
        }
                physicalViewButton.setEnabled(b);
                if (customViewButton != null)
                    customViewButton.setEnabled(b);
            }
        });
    }
    
    

         }
     }
     
    /**
     * @return true if timestamps are OK
     */
    private boolean checkTimeStamps() {
        Set<FileObject> modified = getModifiedFileObjects();
         for (Entry<FileObject, Long> entry: timeStamps.entrySet()) {
             if (modified.contains(entry.getKey()))
                return false;
             if (!entry.getKey().isValid())
                 return false;
             if (entry.getKey().lastModified().getTime() != entry.getValue())
                 return false;
            }
        return true;
    }
     
     private Set<FileObject> getModifiedFileObjects() {
         Set<FileObject> result = new HashSet();

        if (refactorButton != null) {
            refactorButton.requestFocus();
        } else {
            if (tree!=null) {
                tree.requestFocus();
            }
        }
    }
    

    
    private int location;
    public void storeDividerLocation() {
        if (splitPane.getRightComponent()!=null) {
            location = splitPane.getDividerLocation();
        }
    }
    
    public void restoreDeviderLocation() {
        if (splitPane.getRightComponent()!=null) {
            splitPane.setDividerLocation(location);
        }
    }

    private byte getPrefViewType() {

        prefs.putInt(PREF_VIEW_TYPE, currentView);
    }

    private void updateFilters() {
        if(!ui.isQuery()) {
            if(filterBar != null) {
                toolbars.remove(filterBar);
                filterBar = null;
                filtersManager = null;
            }
            return;
        }

        if(filtersManager != null) {
            toolbars.remove(filterBar);
            filterBar = null;
            filtersManager = null;
        }
        final FiltersDescription desc = ui.getRefactoring().getFiltersDescription();
        filtersManager = FiltersManagerImpl.create(desc == null? new FiltersDescription() : desc);
        filterBar = filtersManager.getComponent();
        toolbars.add(filterBar, BorderLayout.EAST);
        filtersManager.hookChangeListener(this);
        toolbars.validate();
    }

    @Override
    public void filterStateChanged(ChangeEvent e) {
        refresh(false);
    }

    ////////////////////////////////////////////////////////////////////////////
    // INNER CLASSES
    ////////////////////////////////////////////////////////////////////////////

            }
            // expandAll button selected/deselected
            else if (o == expandButton && tree != null) {
                if (expandButton.isSelected()) {
                    expandAll();
                } else {
                    collapseAll();
                }
            } else if (o == refreshButton) {
                if (callback!=null) {
                    close();


    private void stopSearch() {
        stopButton.setEnabled(false);
        stopButton.setVisible(false);
        refreshButton.setVisible(true);
        cancelRequest.set(true);
        ui.getRefactoring().cancelRequest();
    }




 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */
package org.netbeans.modules.refactoring.spi.ui;
package org.netbeans.modules.java.navigation.base;

import java.util.ArrayList;
import java.util.List;
import javax.swing.Icon;
import org.netbeans.api.annotations.common.NonNull;

/**
 * @author Ralph Benjamin Ruijs <ralphbenjamin@netbeans.org>
 * @since 1.29
 */
public final class FiltersDescription {

    /**
     * List of {@code FilterItem}s describing filters properties
     */

    /** List of <FilterItem> describing filters properties */
    private List<FilterItem> filters;

    /**
     * Creates a new instance of FiltersDescription
     */
    public FiltersDescription() {
        filters = new ArrayList<FilterItem>();
    }

    /**
     * Add a new filter to the FiltersDescription. Filters are by default
     * disabled. {@code FiltersDescription.Provider}s should enable them when
     * used.
     *
     * @param key identifier for the filter
     * @param tooltip text to display in the tooltip of the filter button
     * @param selected true if the filter should be selected
     * @param icon icon to use for the filter button
     */
    public void addFilter(@NonNull String key, @NonNull String tooltip,
            boolean selected, @NonNull Icon icon) {
        FilterItem newItem = new FilterItem(key, tooltip, selected, icon);
        filters.add(newItem);
    }

    /**
     * Returns the number of filters in this description.
     *
     * @return the number of filters in this description
     */
    public int getFilterCount() {
        return filters.size();
    }

    /**
     * Returns the key of the filter at the supplied index.
     *
     * @param index the index of the filter
     * @return the key
     * @throws IndexOutOfBoundsException if the index is out of range
     * ({@code index < 0 || index >= size()})
     */
    public @NonNull
    String getKey(int index) {
        return filters.get(index).key;
    }

    /**
     * Returns the tooltip of the filter at the supplied index.
     *
     * @param index the index of the filter
     * @return the tooltip
     * @throws IndexOutOfBoundsException if the index is out of range
     * ({@code index < 0 || index >= size()})
     */
    public @NonNull
    String getTooltip(int index) {
        return filters.get(index).tooltip;
    }

    /**
     * Returns the icon of the filter at the supplied index.
     *
     * @param index the index of the filter
     * @return the icon
     * @throws IndexOutOfBoundsException if the index is out of range
     * ({@code index < 0 || index >= size()})
     */
    public @NonNull
    Icon getIcon(int index) {
        return filters.get(index).icon;
    }

    /**
     * Returns true if the filter at the supplied index is selected.
     *
     * @param index the index of the filter
     * @return true if the filter is selected.
     * @throws IndexOutOfBoundsException if the index is out of range
     * ({@code index < 0 || index >= size()})
     */
    public boolean isSelected(int index) {
        return filters.get(index).selected;
    }

    /**
     * Enable the filter at the supplied index.
     *
     * @param index the index of the filter
     * @throws IndexOutOfBoundsException if the index is out of range
     * ({@code index < 0 || index >= size()})
     */
    public void enable(int index) {
        filters.get(index).enabled = true;
    }

    /**
     * Enable the filter with the supplied key. If there is no filter with the
     * supplied key, nothing will change.
     *
     * @param key the key of a filter
     */
    public void enable(@NonNull String key) {
        for (FilterItem filterItem : filters) {
            if (filterItem.key.contentEquals(key)) {
                filterItem.enabled = true;
                break;
            }
        }
    }

    /**
     * Returns true if the filter at the supplied index is enabled.
     *
     * @param index the index of the filter
     * @return true if the filter is enabled.
     * @throws IndexOutOfBoundsException if the index is out of range
     * ({@code index < 0 || index >= size()})
     */
    public boolean isEnabled(int index) {
        return filters.get(index).enabled;
    }

    private static class FilterItem {

        String key;
        String tooltip;
        Icon icon;
        boolean selected;
        boolean enabled;

        FilterItem(String key, String tooltip,
                boolean selected, Icon icon) {
            this.key = key;
            this.displayName = displayName;
            this.tooltip = tooltip;
            this.icon = icon;
            this.selected = selected;
            this.enabled = false;
        }
        
    }

    /**
     * {@code RefactoringPlugin}s can implement this interface if they want to
     * supply new filters, or enable existing filters.
     */
    public static interface Provider {

        /**
         * Add filters to the supplied {@code FiltersDescription}. This method
         * will be called after the plugin is received from the
         * {@code RefactoringPluginFactory}.
         *
         * @param filtersDescription the {@code FiltersDescription} to add filters to
         * @see FiltersDescription#addFilter
         */
        void addFilters(FiltersDescription filtersDescription);

        /**
         * Enable filters in the supplied {@code FiltersDescription}. This method
         * will be called after the plugins {@code RefactoringPlugin#prepare} method is called.
         *
         * @param filtersDescription the {@code FiltersDescription} to enable filters from
         * @see FiltersDescription#enable
         */
        void enableFilters(FiltersDescription filtersDescription);
    }
}

Return to bug 215361

Lines 255-260 Link Here

(-)a/refactoring.api/src/org/netbeans/modules/refactoring/api/RefactoringSession.java (+10 lines)
255	}	255	}
256		256
257	/**	257	/**
		258	* Indicates if this session is finished.
		259	* @return true if this session is finished, false otherwise
		260	* @see #finished()
		261	* @since 1.29
		262	*/
		263	public boolean isFinished() {
		264	return finished.get();
		265	}
		266
		267	/**
258	* Adds progress listener to this RefactoringSession	268	* Adds progress listener to this RefactoringSession
259	* @param listener to add	269	* @param listener to add
260	*/	270	*/

Lines 49-54 Link Here

(-)a/refactoring.api/apichanges.xml (+21 lines)
49	<apidef name="refactoring">Refactoring API</apidef>	49	<apidef name="refactoring">Refactoring API</apidef>
50	</apidefs>	50	</apidefs>
51	<changes>	51	<changes>
		52	<change id="RefactoringResultsFilters">
		53	<api name="refactoring"/>
		54	<summary>Added an API to support filters of the Find Usages results.</summary>
		55	<version major="1" minor="29"/>
		56	<date day="10" month="7" year="2012"/>
		57	<author login="ralphbenjamin"/>
		58	<compatibility addition="yes"/>
		59	<description>
		60	<p>
		61	This API allows refactoring plugins to add/enable filters to the
		62	results window and refactoring elements to specify if they should
		63	be included in the results.
		64	</p>
		65	</description>
		66	<class package="org.netbeans.modules.refactoring.api" name="AbstractRefactoring"/>
		67	<class package="org.netbeans.modules.refactoring.api" name="RefactoringElement"/>
		68	<class package="org.netbeans.modules.refactoring.api" name="RefactoringSession"/>
		69	<class package="org.netbeans.modules.refactoring.spi" name="FiltersManager"/>
		70	<class package="org.netbeans.modules.refactoring.spi.ui" name="FiltersDescription"/>
		71	<issue number="215361"/>
		72	</change>
52	<change id="FinishSession">	73	<change id="FinishSession">
53	<api name="refactoring"/>	74	<api name="refactoring"/>
54	<summary>Changed access level of #finish() to public.</summary>	75	<summary>Changed access level of #finish() to public.</summary>

Line 0 Link Here

(-)a/refactoring.api/src/org/netbeans/modules/refactoring/spi/FiltersManager.java (+80 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.refactoring.spi;
		43
		44	import org.netbeans.modules.refactoring.api.RefactoringElement;
		45	import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;
		46
		47	/**
		48	* Handles creation and manipulation with boolean state filters.
		49	*
		50	* @author Ralph Benjamin Ruijs <ralphbenjamin@netbeans.org>
		51	* @see FiltersDescription
		52	* @since 1.29
		53	*/
		54	public abstract class FiltersManager {
		55
		56	/**
		57	* Indicates if a filter is selected.
		58	*
		59	* @param filterName the name of the filter to check
		60	* @return Returns true when given filter is selected, false otherwise.
		61	*/
		62	public abstract boolean isSelected(String filterName);
		63
		64	/**
65	* {@code RefactoringElement}s should implement this interface if they
66	* should be filterable in the results.
67	*
68	* @see RefactoringElement#include
69	*/
70	public static interface Filterable {
71
72	/**
73	* Indicates if this element should be included in the results.
74	*
75	* @param manager the FiltersManager to use
76	* @return true if this element should be included
77	*/
78	boolean filter(FiltersManager manager);
79	}
80	}

Lines 41-48 Link Here

(-)a/java.navigation/src/org/netbeans/modules/java/navigation/base/FiltersManager.java (-157 / +153 lines)
41	* Version 2 license, then the option applies only if the new code is	41	* Version 2 license, then the option applies only if the new code is
42	* made subject to such option by the copyright holder.	42	* made subject to such option by the copyright holder.
43	*/	43	*/
44		44	package org.netbeans.modules.refactoring.spi.impl;
45	package org.netbeans.modules.java.navigation.base;
46		45
47	import java.awt.Dimension;	46	import java.awt.Dimension;
48	import java.awt.Insets;	47	import java.awt.Insets;
Lines 52-157 Link Here
52	import java.util.HashMap;	51	import java.util.HashMap;
53	import java.util.List;	52	import java.util.List;
54	import java.util.Map;	53	import java.util.Map;
55	import java.util.prefs.Preferences;
56	import javax.swing.BorderFactory;
57	import javax.swing.Box;
58	import javax.swing.BoxLayout;
59	import javax.swing.Icon;	54	import javax.swing.Icon;
60	import javax.swing.JComponent;
61	import javax.swing.JToggleButton;	55	import javax.swing.JToggleButton;
62	import javax.swing.JToolBar;	56	import javax.swing.JToolBar;
63	import javax.swing.SwingUtilities;	57	import javax.swing.SwingUtilities;
64	import javax.swing.border.EmptyBorder;
65	import javax.swing.event.ChangeEvent;	58	import javax.swing.event.ChangeEvent;
66	import org.netbeans.modules.java.navigation.NoBorderToolBar;	59	import org.netbeans.modules.refactoring.spi.FiltersManager;
		60	import org.netbeans.modules.refactoring.spi.ui.FiltersDescription;
67	import org.openide.util.Mutex;	61	import org.openide.util.Mutex;
68	import org.openide.util.NbPreferences;
69		62
70	/** Handles creation and manipulation with boolean state filters.	63	/**
		64	* Handles creation and manipulation with boolean state filters.
71	*	65	*
72	* @author Dafe Simomek	66	* @author Dafe Simomek
73	*/	67	*/
74	public final class FiltersManager {	68	public final class FiltersManagerImpl extends FiltersManager {
75		69
76	private FiltersComponent comp;	70	private FiltersComponent comp;
77		71
78	static FiltersManager create (FiltersDescription descr) {	72	static FiltersManagerImpl create(FiltersDescription descr) {
79	return new FiltersManager(descr);	73	return new FiltersManagerImpl(descr);
80	}	74	}
81		75
82	/** Returns true when given filter is selected, false otherwise.	76	/**
83	* Note that this method is thread safe, can be called from any thread	77	* Indicates if a filter is selected.
84	* (and usually will, as clients will call this from loadContent naturally)	78	*
		79	* @param filterName the name of the filter to check
		80	* @return Returns true when given filter is selected, false otherwise.
85	*/	81	*/
86	public boolean isSelected (String filterName) {	82	@Override
		83	public boolean isSelected(String filterName) {
87	return comp.isSelected(filterName);	84	return comp.isSelected(filterName);
88	}	85	}
89		86
90	/** Sets boolean value of filter with given name. True means filter is	87	/**
91	* selected (enabled), false otherwise. Note, must be called from AWT thread.	88	* Sets boolean value of filter with given name. True means filter is
		89	* selected (enabled), false otherwise. Note, must be called from AWT
		90	* thread.
92	*/	91	*/
93	public void setSelected (String filterName, boolean value) {	92	public void setSelected(String filterName, boolean value) {
94	comp.setFilterSelected(filterName, value);	93	comp.setFilterSelected(filterName, value);
95	}	94	}
96		95
97	/** @return component instance visually representing filters */	96	/**
98	public JComponent getComponent ( JToggleButton[] sortButtons ) {	97	* @return component instance visually representing filters
99	comp.addSortButtons( sortButtons );	98	*/
100	return comp;	99	public JToolBar getComponent(JToggleButton... additionalButtons) {
		100	if(additionalButtons != null && additionalButtons.length > 0) {
		101	comp.addAdditionalButtons(additionalButtons);
		102	}
		103	return comp.toolbar;
101	}	104	}
102		105
103	/** @return Filters description */	106	/**
104	public FiltersDescription getDescription () {	107	* @return Filters description
		108	*/
		109	public FiltersDescription getDescription() {
105	return comp.getDescription();	110	return comp.getDescription();
106	}	111	}
107		112
108	/** Assigns listener for listening to filter changes */	113	/**
109	public void hookChangeListener (FilterChangeListener l) {	114	* Assigns listener for listening to filter changes
		115	*/
		116	public void hookChangeListener(FilterChangeListener l) {
110	comp.hookFilterChangeListener(l);	117	comp.hookFilterChangeListener(l);
111	}	118	}
112		119
113	/** Interface for listening to changes of filter states contained in FIltersPanel	120	/**
		121	* Interface for listening to changes of filter states contained in
		122	* FIltersPanel
114	*/	123	*/
115	public interface FilterChangeListener {	124	public interface FilterChangeListener {
116	/** Called whenever some changes in state of filters contained in	125
117	* filters panel is triggered	126	/**
		127	* Called whenever some changes in state of filters contained in filters
		128	* panel is triggered
118	*/	129	*/
119	public void filterStateChanged(ChangeEvent e);	130	public void filterStateChanged(ChangeEvent e);
120
121	} // end of FilterChangeListener	131	} // end of FilterChangeListener
122
123		132
124	/** Private, creation managed by factory method 'create' */	133	/**
125	private FiltersManager (FiltersDescription descr) {	134	* Private, creation managed by factory method 'create'
		135	*/
		136	private FiltersManagerImpl(FiltersDescription descr) {
126	comp = new FiltersComponent(descr);	137	comp = new FiltersComponent(descr);
127	}	138	}
128		139
129	/** Swing component representing filters in panel filled with toggle buttons.	140	/**
		141	* Swing component representing filters in panel filled with toggle buttons.
130	* Provides thread safe access to the states of filters by copying states	142	* Provides thread safe access to the states of filters by copying states
131	* into private map, properly sync'ed.	143	* into private map, properly sync'ed.
132	*/	144	*/
133	private class FiltersComponent extends Box implements ActionListener {	145	private class FiltersComponent implements ActionListener {
134		146
135	/** list of <JToggleButton> visually representing filters */	147	/**
		148	* list of <JToggleButton> visually representing filters
		149	*/
136	private List<JToggleButton> toggles;	150	private List<JToggleButton> toggles;
137	/** description of filters */	151	/**
		152	* description of filters
		153	*/
138	private final FiltersDescription filtersDesc;	154	private final FiltersDescription filtersDesc;
139		155	/**
140	/** lock for listener */	156	* lock for listener
141	private Object L_LOCK = new Object();	157	*/
142	/** listener */	158	private final Object L_LOCK = new Object();
		159	/**
		160	* listener
		161	*/
143	private FilterChangeListener clientL;	162	private FilterChangeListener clientL;
144		163	/**
145	/** lock for map of filter states */	164	* lock for map of filter states
146	private Object STATES_LOCK = new Object();	165	*/
147	/** copy of filter states for accessing outside AWT */	166	private final Object STATES_LOCK = new Object();
148	private Map<String,Boolean> filterStates;	167	/**
149		168	* copy of filter states for accessing outside AWT
		169	*/
		170	private Map<String, Boolean> filterStates;
150	private JToolBar toolbar;	171	private JToolBar toolbar;
151		172
152	/** Returns selected state of given filter, thread safe.	173	/**
		174	* Returns selected state of given filter, thread safe.
153	*/	175	*/
154	public boolean isSelected (String filterName) {	176	public boolean isSelected(String filterName) {
155	Boolean result;	177	Boolean result;
156	synchronized (STATES_LOCK) {	178	synchronized (STATES_LOCK) {
157	if (filterStates == null) {	179	if (filterStates == null) {
Lines 165-181 Link Here
165	}	187	}
166	result = filterStates.get(filterName);	188	result = filterStates.get(filterName);
167	}	189	}
168		190
169	if (result == null) {	191	if (result == null) {
170	throw new IllegalArgumentException("Filter " + filterName + " not found.");	192	throw new IllegalArgumentException("Filter " + filterName + " not found.");
171	}	193	}
172	return result.booleanValue();	194	return result.booleanValue();
173	}	195	}
174		196
175	/** Sets filter value, AWT only */	197	/**
176	public void setFilterSelected (String filterName, boolean value) {	198	* Sets filter value, AWT only
		199	*/
		200	public void setFilterSelected(String filterName, boolean value) {
177	assert SwingUtilities.isEventDispatchThread();	201	assert SwingUtilities.isEventDispatchThread();
178		202
179	int index = filterIndexForName(filterName);	203	int index = filterIndexForName(filterName);
180	if (index < 0) {	204	if (index < 0) {
181	throw new IllegalArgumentException("Filter " + filterName + " not found.");	205	throw new IllegalArgumentException("Filter " + filterName + " not found.");
Lines 188-299 Link Here
188	// notify	212	// notify
189	fireChange();	213	fireChange();
190	}	214	}
191		215
192	public void hookFilterChangeListener (FilterChangeListener l) {	216	public void hookFilterChangeListener(FilterChangeListener l) {
193	synchronized (L_LOCK) {	217	synchronized (L_LOCK) {
194	clientL = l;	218	clientL = l;
195	}	219	}
196	}	220	}
197		221
198	public FiltersDescription getDescription () {	222	public FiltersDescription getDescription() {
199	return filtersDesc;	223	return filtersDesc;
200	}	224	}
201		225
202	/** Not public, instances created using factory method createPanel */	226	/**
		227	* Not public, instances created using factory method createPanel
		228	*/
203	FiltersComponent(FiltersDescription descr) {	229	FiltersComponent(FiltersDescription descr) {
204	super(BoxLayout.X_AXIS);
205	this.filtersDesc = descr;	230	this.filtersDesc = descr;
206	// always create swing content in AWT thread	231	// always create swing content in AWT thread
207	Mutex.EVENT.readAccess(new Runnable () {	232	Mutex.EVENT.readAccess(new Runnable() {
208	public void run () {	233	@Override
209	initPanel();	234	public void run() {
		235	initPanel();
210	}	236	}
211	});	237	});
212	}	238	}
213		239
214	/** Called only from AWT */	240	/**
215	private void initPanel () {	241	* Called only from AWT
216	setBorder(new EmptyBorder(1, 2, 3, 5));	242	*/
217		243	private void initPanel() {
218	// configure toolbar	244	// configure toolbar
219	toolbar = new NoBorderToolBar(JToolBar.HORIZONTAL);	245	toolbar = new JToolBar(JToolBar.VERTICAL);
220	toolbar.setFloatable(false);	246	toolbar.setFloatable(false);
221	toolbar.setRollover(true);	247	toolbar.setRollover(true);
222	toolbar.setBorderPainted(false);	248	toolbar.setBorderPainted(true);
223	toolbar.setBorder(BorderFactory.createEmptyBorder());	249	toolbar.setBorder(
		250	javax.swing.BorderFactory.createCompoundBorder(
		251	javax.swing.BorderFactory.createMatteBorder(0, 1, 0, 0,
		252	javax.swing.UIManager.getDefaults().getColor("Separator.foreground")), //NOI18N
		253	javax.swing.BorderFactory.createEmptyBorder(0, 1, 0, 0)));
224	toolbar.setOpaque(false);	254	toolbar.setOpaque(false);
225	toolbar.setFocusable(false);	255	toolbar.setFocusable(false);
226	// create toggle buttons	256	// create toggle buttons
227	int filterCount = filtersDesc.getFilterCount();	257	int filterCount = filtersDesc.getFilterCount();
228	toggles = new ArrayList<JToggleButton>(filterCount);	258	toggles = new ArrayList<JToggleButton>(filterCount);
229	JToggleButton toggleButton = null;	259	JToggleButton toggleButton;
230		260
231	Map<String,Boolean> fStates = new HashMap<String, Boolean>(filterCount * 2);	261	Map<String, Boolean> fStates = new HashMap<String, Boolean>(filterCount * 2);
232		262
233	for (int i = 0; i < filterCount; i++) {	263	for (int i = 0; i < filterCount; i++) {
234	toggleButton = createToggle(fStates, i);	264	toggleButton = createToggle(fStates, i);
235	toggles.add(toggleButton);	265	toggles.add(toggleButton);
236	}	266	}
237		267
238	// add toggle buttons	268	// add toggle buttons
239	JToggleButton curToggle;	269	JToggleButton curToggle;
240	for (int i = 0; i < toggles.size(); i++) {	270	for (int i = 0; i < toggles.size(); i++) {
241	curToggle = toggles.get(i);	271	curToggle = toggles.get(i);
242	curToggle.addActionListener(this);	272	curToggle.addActionListener(this);
243	toolbar.add(curToggle);	273	toolbar.add(curToggle);
244	if (i != toggles.size() - 1) {
245	toolbar.add(new Space());
246	}
247	}	274	}
248		275
249	add(toolbar);
250
251	// initialize member states map	276	// initialize member states map
252	synchronized (STATES_LOCK) {	277	synchronized (STATES_LOCK) {
253	filterStates = fStates;	278	filterStates = fStates;
254	}	279	}
255	}	280	}
256		281
257	private void addSortButtons( JToggleButton[] sortButtons ) {	282	private void addAdditionalButtons(JToggleButton[] sortButtons) {
258	Dimension space = new Dimension(3, 0);	283	Dimension space = new Dimension(3, 0);
259	for( JToggleButton button : sortButtons ) {	284	for (JToggleButton button : sortButtons) {
260	Icon icon = button.getIcon();	285	Dimension size = new Dimension(21, 21); // 3 less than other buttons
261	Dimension size = new Dimension(icon.getIconWidth() + 6, icon.getIconHeight() + 4);	286	button.setMaximumSize(size);
		287	button.setMinimumSize(size);
262	button.setPreferredSize(size);	288	button.setPreferredSize(size);
263	button.setMargin(new Insets(2,3,2,3));	289	// button.setMargin(new Insets(2, 3, 2, 3));
264	toolbar.addSeparator(space);	290	toolbar.addSeparator(space);
265	toolbar.add( button );	291	toolbar.add(button);
266	}	292	}
267	}	293	}
268		294
269	private Preferences getPreferences() {	295	private JToggleButton createToggle(Map<String, Boolean> fStates, int index) {
270	return NbPreferences.forModule( FiltersManager.class );	296	boolean isSelected = filtersDesc.isSelected(index);
271	}	297	Icon icon = filtersDesc.getIcon(index);
272
273	private JToggleButton createToggle (Map<String,Boolean> fStates, int index) {
274	boolean isSelected = getPreferences().getBoolean( filtersDesc.getName(index), filtersDesc.isSelected(index) );
275	Icon icon = filtersDesc.getSelectedIcon(index);
276	// ensure small size, just for the icon	298	// ensure small size, just for the icon
277	JToggleButton result = new JToggleButton(icon, isSelected);	299	JToggleButton result = new JToggleButton(icon, isSelected);
278	Dimension size = new Dimension(icon.getIconWidth() + 6, icon.getIconHeight() + 4);	300	Dimension size = new Dimension(21, 21); // 3 less than other buttons
		301	result.setMaximumSize(size);
		302	result.setMinimumSize(size);
279	result.setPreferredSize(size);	303	result.setPreferredSize(size);
280	result.setMargin(new Insets(2,3,2,3));	304	result.setBorderPainted(false);
		305	// result.setMargin(new Insets(2, 3, 2, 3));
281	result.setToolTipText(filtersDesc.getTooltip(index));	306	result.setToolTipText(filtersDesc.getTooltip(index));
282	result.setFocusable(false);	307	result.setEnabled(filtersDesc.isEnabled(index));
283		308	fStates.put(filtersDesc.getKey(index), Boolean.valueOf(isSelected));
284	fStates.put(filtersDesc.getName(index), Boolean.valueOf(isSelected));	309
285
286	return result;	310	return result;
287	}	311	}
288		312
289	/** Finds and returns index of filter with given name or -1 if no	313	/**
290	* such filter exists.	314	* Finds and returns index of filter with given name or -1 if no such
		315	* filter exists.
291	*/	316	*/
292	private int filterIndexForName (String filterName) {	317	private int filterIndexForName(String filterName) {
293	int filterCount = filtersDesc.getFilterCount();	318	int filterCount = filtersDesc.getFilterCount();
294	String curName;	319	String curName;
295	for (int i = 0; i < filterCount; i++) {	320	for (int i = 0; i < filterCount; i++) {
296	curName = filtersDesc.getName(i);	321	curName = filtersDesc.getKey(i);
297	if (filterName.equals(curName)) {	322	if (filterName.equals(curName)) {
298	return i;	323	return i;
299	}	324	}
Lines 301-320 Link Here
301	return -1;	326	return -1;
302	}	327	}
303		328
304	/** Reactions to toggle button click, */	329	/**
		330	* Reactions to toggle button click,
		331	*/
		332	@Override
305	public void actionPerformed(ActionEvent e) {	333	public void actionPerformed(ActionEvent e) {
306	// copy changed state first	334	// copy changed state first
307	JToggleButton toggle = (JToggleButton)e.getSource();	335	JToggleButton toggle = (JToggleButton) e.getSource();
308	int index = toggles.indexOf(e.getSource());	336	int index = toggles.indexOf(e.getSource());
309	synchronized (STATES_LOCK) {	337	synchronized (STATES_LOCK) {
310	filterStates.put(filtersDesc.getName(index),	338	filterStates.put(filtersDesc.getKey(index),
311	Boolean.valueOf(toggle.isSelected()));	339	Boolean.valueOf(toggle.isSelected()));
312	}	340	}
313	// notify	341	// notify
314	fireChange();	342	fireChange();
315	}	343	}
316		344
317	private void fireChange () {	345	private void fireChange() {
318	FilterChangeListener lCopy;	346	FilterChangeListener lCopy;
319	synchronized (L_LOCK) {	347	synchronized (L_LOCK) {
320	// no listener = no notification	348	// no listener = no notification
Lines 323-363 Link Here
323	}	351	}
324	lCopy = clientL;	352	lCopy = clientL;
325	}	353	}
326		354
327	// notify listener	355	// notify listener
328	lCopy.filterStateChanged(new ChangeEvent(FiltersManager.this));	356	lCopy.filterStateChanged(new ChangeEvent(FiltersManagerImpl.this));
329	}	357	}
330
331	@Override
332	public void removeNotify() {
333	//remember filter settings
334	if( null != filterStates ) {
335	Preferences prefs = getPreferences();
336	for( String filterName : filterStates.keySet() ) {
337	prefs.putBoolean( filterName, filterStates.get( filterName ) );
338	}
339	}
340	super.removeNotify();
341	}
342
343	} // end of FiltersComponent	358	} // end of FiltersComponent
344
345	private static class Space extends JComponent {
346
347	private static final Dimension SPACE = new Dimension(3, 3);
348
349	@Override
350	public Dimension getPreferredSize() {
351	return getMinimumSize();
352	}
353	@Override
354	public Dimension getMaximumSize() {
355	return getMinimumSize();
356	}
357	@Override
358	public Dimension getMinimumSize() {
359	return SPACE;
360	}
361	}
362
363	}	359	}