Attachment #116427 for bug #208794

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 208794
Collapse All | Expand All




<apidef name="explorer">Explorer API</apidef>
</apidefs>
<changes>
    <change id="OutlineView_with_quicksearch">
        <api name="explorer"/>
        <summary>QuickSearch attached to OutlineView</summary>
        <version major="6" minor="43"/>
        <date day="29" month="2" year="2012"/>
        <author login="mentlicher"/>
        <compatibility binary="compatible" source="compatible" deprecation="no" deletion="no" addition="yes"/>
        <description>
            Added <a href="@TOP@/org/openide/explorer/view/OutlineView.html#getQuickSearch()">OutlineView.getQuickSearch()</a>
            method to get and control quick search functionality on OutlineView.
        </description>
        <class package="org.openide.explorer.view" name="OutlineView"/>
        <issue number="110686"/>
    </change>
    <change id="PropertyEnv.create">
        <api name="explorer"/>
        <summary>API method for creating a PropertyEnv instance</summary>

Lines 2-6 Link Here

(-)a/openide.explorer/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.openide.explorer	2	OpenIDE-Module: org.openide.explorer
3	OpenIDE-Module-Localizing-Bundle: org/openide/explorer/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/openide/explorer/Bundle.properties
4	AutoUpdate-Essential-Module: true	4	AutoUpdate-Essential-Module: true
5	OpenIDE-Module-Specification-Version: 6.42	5	OpenIDE-Module-Specification-Version: 6.43
6		6

Lines 70-76 Link Here

(-)a/openide.explorer/nbproject/project.xml (-1 / +1 lines)
70	<build-prerequisite/>	70	<build-prerequisite/>
71	<compile-dependency/>	71	<compile-dependency/>
72	<run-dependency>	72	<run-dependency>
73	<specification-version>6.2</specification-version>	73	<specification-version>7.43</specification-version>
74	</run-dependency>	74	</run-dependency>
75	</dependency>	75	</dependency>
76	<dependency>	76	<dependency>




import javax.swing.BorderFactory;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JMenu;
import javax.swing.JPopupMenu;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;

import org.netbeans.swing.outline.TreePathSupport;
import org.openide.awt.Mnemonics;
import org.openide.awt.MouseUtils;
import org.openide.awt.QuickSearch;
import org.openide.explorer.ExplorerManager;
import org.openide.explorer.ExplorerUtils;
import org.openide.explorer.propertysheet.PropertyPanel;

        rowModel = new PropertiesRowModel();
        model = createOutlineModel(treeModel, rowModel, nodesColumnLabel);
        outline = new OutlineViewOutline(model, rowModel);
        TableQuickSearchSupport tqss = outline.createDefaultTableQuickSearchSupport();
        attachQuickSearch(tqss, false, tqss.createSearchPopupMenu());
        quickSearch.addQuickSearchListener(tqss);
        outline.addKeyListener(new KeyListener() {
            @Override
            public void keyTyped(KeyEvent e) {

                quickSearch.processKeyEvent(e);
            }
        });
        quickSearch.setPopupMenu(tqss.createSearchPopupMenu());
        rowModel.setOutline(outline);
        outline.setRenderDataProvider(new NodeRenderDataProvider(outline));
        SheetCell tableCell = new SheetCell.OutlineSheetCell(outline);


        initializeTreeScrollSupport();
    }
    
    private void attachQuickSearch(QuickSearch.Callback callback, boolean asynchronous, JMenu popup) {
        if (quickSearch != null) {
            quickSearch.detach();
        }
        quickSearch = QuickSearch.attach(this, searchConstraints, callback, asynchronous, popup);
    }

    @Override
    public void add(Component comp, Object constraints) {

    /**
     * Test whether the quick search feature is enabled or not.
     * Default is enabled (true).
     * @since 6.43
     * @return true if quick search feature is enabled, false otherwise.
     */
    public boolean isQuickSearchAllowed() {
        return quickSearch.isEnabled();
    }
    
    /**
     * Set whether the quick search feature is enabled or not.
     * @since 6.43
     * @param allowedQuickSearch <code>true</code> if quick search shall be enabled
     */
    public void setQuickSearchAllowed(boolean allowedQuickSearch) {
        quickSearch.setEnabled(allowedQuickSearch);
    }

    /**
     * Set a quick search filter.
     * @param quickSearchTableFilter The quick search filter
     * @param asynchronous
     * @since 6.43
     */
    public void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter, boolean asynchronous) {
        TableQuickSearchSupport tqss = outline.createTableQuickSearchSupport(quickSearchTableFilter);
        attachQuickSearch(tqss, asynchronous, tqss.createSearchPopupMenu());
    }
    
    /** Initializes the component and lookup explorer manager.
     */
    @Override

     * Extension of the ETable that allows adding a special comparator
     * for sorting the rows.
     */
    static class OutlineViewOutline extends Outline {
        private final PropertiesRowModel rowModel;
        private static final String COLUMNS_SELECTOR_HINT = "ColumnsSelectorHint"; // NOI18N
        private static final String COPY_ACTION_DELEGATE = "Outline Copy Action Delegate "; // NOI18N

            }
            return null;
        }
        
        private TableQuickSearchSupport createDefaultTableQuickSearchSupport() {
            return new TableQuickSearchSupport(this, new DefaultQuickSearchTableFilter(), qss);
        }

        private TableQuickSearchSupport createTableQuickSearchSupport(QuickSearchTableFilter quickSearchTableFilter) {
            return new TableQuickSearchSupport(this, quickSearchTableFilter, qss);
        }
        
        private final class DefaultQuickSearchTableFilter implements QuickSearchTableFilter {

            @Override
            public String getStringValueAt(int row, int col) {
                Object value = transformValue(getValueAt(row, col));
                String str;
                if (value instanceof Property) {
                    Property p = (Property) value;
                    Object v = null;
                    try {
                        v = p.getValue();
                    } catch (IllegalAccessException ex) {
                    } catch (InvocationTargetException ex) {
                    }
                    if (v instanceof String) {
                        str = (String) v;
                    } else {
                        str = null;
                    }
                } else if (value instanceof VisualizerNode) {
                    str = ((VisualizerNode) value).getDisplayName();
                } else if (value instanceof Node) {
                    str = ((Node) value).getDisplayName();
                } else if (value instanceof String) {
                    str = (String) value;
                } else {
                    str = null;
                }
                return str;
                str = ((VisualizerNode) value).getDisplayName();
            } else if (value instanceof Node) {
                str = ((Node) value).getDisplayName();
            } else if (value instanceof String) {
                str = (String) value;
            } else {
                str = null;
            }
        
        }

        private class CopyToClipboardAction implements Action {




/*
 * 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.openide.explorer.view;

/**
 *
 * @author Martin Entlicher
 */
public interface QuickSearchTableFilter {
    
    String getStringValueAt(int row, int col);
    
}




import javax.swing.event.ChangeListener;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import org.openide.awt.QuickSearch;
import org.openide.util.NbBundle;
import org.openide.util.NbPreferences;


 * 
 * @author Martin Entlicher
 */
class TableQuickSearchSupport implements QuickSearch.Callback {
    
    private int quickSearchInitialRow = -1;     // The search was initiated here
    private int quickSearchInitialColumn = -1;  // The search was initiated here

    private String lastSearchText;
    
    private JTable table;
    //private StringValuedTable svTable;
    private QuickSearchTableFilter quickSearchTableFilter;
    private QuickSearchSettings qss;
    
    TableQuickSearchSupport(JTable table, QuickSearchTableFilter quickSearchTableFilter, QuickSearchSettings qss) {
        this.table = table;
        this.quickSearchTableFilter = quickSearchTableFilter;
        this.qss = qss;
    }
    
    public void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter, boolean asynchronous) {
        this.quickSearchTableFilter = quickSearchTableFilter;
    }

    @Override
    public void quickSearchUpdate(String searchText) {
        lastSearchText = searchText;

        }
        quickSearchLastRow = quickSearchInitialRow;
        quickSearchLastColumn = quickSearchInitialColumn;
        doSearch(searchText, true);
    }

    @Override
    public void showNextSelection(boolean forward) {
        if (forward) {
            if (++quickSearchLastColumn >= table.getColumnCount()) {
                quickSearchLastColumn = 0;
                if (++quickSearchLastRow >= table.getRowCount()) {

                }
            }
        }
        doSearch(lastSearchText, forward);
    }

    @Override

        String maxPrefix = null;
        for (int row = row1; row < row2; row++) {
            for (int col = col1; col < col2; col++) {
                String str = quickSearchTableFilter.getStringValueAt(row, col);
                String strUp;
                if (qss.isMatchCase()) {
                    strUp = str;

                    if (maxPrefix == null) {
                        maxPrefix = str;
                    } else {
                        maxPrefix = QuickSearch.findMaxPrefix(maxPrefix, str, !qss.isMatchCase());
                    }
                }
            }

        quickSearchInitialColumn = -1;
    }

    private void doSearch(String searchText, boolean forward) {
        if (!qss.isMatchCase()) {
            searchText = searchText.toUpperCase();
        }
        int n = table.getRowCount();
        //boolean backward = bias == Position.Bias.Backward;
        int row1 = quickSearchLastRow;
        int row2 = quickSearchLastRow + n;
        boolean lineStartSearch = true;
        Set<String> columnsIgnoredToSearch = qss.getColumnsIgnoredToSearch();
        do {
            int col1 = quickSearchLastColumn;
            int col2 = (forward) ? table.getColumnCount() : 0;
            for (int row = (forward) ? row1 : (row2 - 1); (forward) ? row < row2 : row >= row1; row = (forward) ? ++row : --row) {
                for (int col = col1; (forward) ? col < col2 : col >= col2; col = (forward) ? ++col : --col) {
                    String cName = table.getColumnName(col);
                    if (columnsIgnoredToSearch.contains(cName)) {
                        continue;
                    }
                    String str = quickSearchTableFilter.getStringValueAt(row % n, col);
                    if (str == null) {
                        continue;
                    }

                        }
                    }
                }
                col1 = (forward) ? 0 : table.getColumnCount() - 1;
            }
            lineStartSearch = !lineStartSearch;
        } while (!lineStartSearch);

                return TableQuickSearchSupport.getSearchPopupMenu(qss, table.getColumnModel(), new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        doSearch(lastSearchText, true);
                    }
                });
            }




 *
 * @author Jan Rojcek
 */
class TreeTable extends JTable implements Runnable {
    /** Action key for up/down focus action */
    private static final String ACTION_FOCUS_NEXT = "focusNext"; //NOI18N
    private static Color unfocusedSelBg = null;

    QuickSearchSettings getQuickSearchSettings() {
        return qss;
    }
    
    private QuickSearchTableFilter qstf = new DefaultQuickSearchTableFilter();
    
    QuickSearchTableFilter getQuickSearchTableFilter() {
        return qstf;
    }

    private final class DefaultQuickSearchTableFilter implements QuickSearchTableFilter {

        @Override
        public String getStringValueAt(int row, int col) {
            Object value = getValueAt(row, col);
            String str;
            if (value instanceof Property) {
                Property p = (Property) value;
                Object v = null;
                try {
                    v = p.getValue();
                } catch (IllegalAccessException ex) {
                } catch (InvocationTargetException ex) {
                }
                if (v instanceof String) {
                    str = (String) v;
                } else {
                    str = null;
                }
            } else if (value instanceof VisualizerNode) {
                str = ((VisualizerNode) value).getDisplayName();
                //str = Visualizer.findNode(value).getDisplayName();
            } else {
                str = null;
            }
            return str;
            str = ((VisualizerNode) value).getDisplayName();
            //str = Visualizer.findNode(value).getDisplayName();
        } else {
            str = null;
        }
        
    }
    
    private class GuardedActions implements Mutex.Action<Object> {




import javax.swing.plaf.metal.MetalScrollBarUI;
import javax.swing.table.*;
import javax.swing.tree.*;
import org.openide.awt.QuickSearch;
import org.openide.explorer.view.TreeView.PopupAdapter;
import org.openide.explorer.view.TreeView.PopupSupport;
import org.openide.explorer.view.TreeView.TreePropertyListener;

        TreeTable tt = new TreeTable(treeModel, tableModel);
        treeTable = tt;
        tree = ((TreeTable) treeTable).getTree();
        TableQuickSearchSupport tqss = new TableQuickSearchSupport(tt, tt.getQuickSearchTableFilter(), tt.getQuickSearchSettings());
        quickSearch = QuickSearch.attach(this, searchConstraints, tqss, tqss.createSearchPopupMenu());
        quickSearch.addQuickSearchListener(tqss);
        tt.addKeyListener(new KeyListener() {
            @Override
            public void keyTyped(KeyEvent e) {

                quickSearch.processKeyEvent(e);
            }
        });
        quickSearch.setPopupMenu(tqss.createSearchPopupMenu());
        
        defaultHeaderRenderer = treeTable.getTableHeader().getDefaultRenderer();
        treeTable.getTableHeader().setDefaultRenderer(new SortingHeaderRenderer());




import javax.swing.event.TreeWillExpandListener;
import javax.swing.plaf.TreeUI;
import javax.swing.plaf.UIResource;
import javax.swing.text.Position;
import javax.swing.tree.ExpandVetoException;
import javax.swing.tree.RowMapper;
import javax.swing.tree.TreeCellEditor;

import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import org.openide.awt.QuickSearch;


/**

    transient private int allowedDropActions = DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_REFERENCE;
    
    /** Quick Search support */
    transient private QuickSearch qs;
    transient private KeyAdapter quickSearchKeyAdapter;
    
    /** wait cursor is shown automatically during expanding */
    transient private boolean autoWaitCursor = true;

     * @return true if quick search feature is enabled, false otherwise.
     */
    public boolean isQuickSearchAllowed() {
        return qs.isEnabled();
    }
    
    /**

     * @param allowedQuickSearch <code>true</code> if quick search shall be enabled
     */
    public void setQuickSearchAllowed(boolean allowedQuickSearch) {
        qs.setEnabled(allowedQuickSearch);
         if (quickSearchKeyAdapter != null && tree != null) {
            if (allowedQuickSearch) {
               tree.addKeyListener(quickSearchKeyAdapter);
            } else {
               removeSearchField();
               tree.removeKeyListener(quickSearchKeyAdapter);
            }
         }
    }

    

    }

    @Override
    public void add(Component comp, Object constraints) {
        if (constraints == searchConstraints) {
            searchPanel = comp;
            constraints = null;
        }
        super.add(comp, constraints);
    }
    
    @Override
    public void remove(Component comp) {
        if (comp == searchPanel) {
            searchPanel = null;
        }
        super.remove(comp);
    }
    
    @Override
    public Insets getInsets() {
        Insets res = getInnerInsets();
        res = new Insets(res.top, res.left, res.bottom, res.right);
        if( null != searchPanel && searchPanel.isVisible() ) {
            res.bottom += searchPanel.getPreferredSize().height;
        }
        return res;
    }

    }

    TreePath[] origSelectionPaths = null;
    private Component searchPanel = null;
    private final Object searchConstraints = new Object();
    
    /** Called from tests */
    Component getSearchPanel() {
        return searchPanel;
        }

        @Override
        public void processKeyEvent(KeyEvent ke) {
            //override the default handling so that
            //the parent will never receive the escape key and
            //close a modal dialog
            if (ke.getKeyCode() == KeyEvent.VK_ESCAPE) {
                removeSearchField();
                ke.consume();

                // bugfix #32909, reqest focus when search field is removed
                SwingUtilities.invokeLater(
                    new Runnable() {
                        //additional bugfix - do focus change later or removing
                        //the component while it's focused will cause focus to
                        //get transferred to the next component in the
                        //parent focusTraversalPolicy *after* our request
                        //focus completes, so focus goes into a black hole - Tim
                        @Override
                        public void run() {
                            if( null != tree )
                                tree.requestFocus();
                        }
                    }
                );
            } else {
                super.processKeyEvent(ke);
            }
        }
    };
    private int originalScrollMode;

    private static class SearchPanel extends JPanel {
        public SearchPanel() {
            if( ViewUtil.isAquaLaF )
                setBorder(BorderFactory.createEmptyBorder(9,6,8,2));
            else
                setBorder(BorderFactory.createEmptyBorder(2,6,2,2));
            setOpaque( true );
        }

        @Override
        protected void paintComponent(Graphics g) {
            if( ViewUtil.isAquaLaF && g instanceof Graphics2D ) {
                Graphics2D g2d = (Graphics2D) g;
                g2d.setPaint( new GradientPaint(0, 0, UIManager.getColor("NbExplorerView.quicksearch.background.top"),
                        0, getHeight(), UIManager.getColor("NbExplorerView.quicksearch.background.bottom")));//NOI18N
                g2d.fillRect(0, 0, getWidth(), getHeight());
                g2d.setColor( UIManager.getColor("NbExplorerView.quicksearch.border") ); //NOI18N
                g2d.drawLine(0, 0, getWidth(), 0);
            } else {
                super.paintComponent(g);
            }
        }
    }


    private void prepareSearchPanel() {
        if( searchpanel == null ) {
            searchpanel = new SearchPanel();

            JLabel lbl = new JLabel(NbBundle.getMessage(TreeView.class, "LBL_QUICKSEARCH")); //NOI18N
            searchpanel.setLayout(new BoxLayout(searchpanel, BoxLayout.X_AXIS));
            searchpanel.add(lbl);
            searchpanel.add(searchTextField);
            lbl.setLabelFor(searchTextField);
            searchTextField.setColumns(10);
            searchTextField.setMaximumSize(searchTextField.getPreferredSize());
            searchTextField.putClientProperty("JTextField.variant", "search"); //NOI18N
            lbl.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 5));
        }
    }

    /**
     * Adds the search field to the tree.
     */
    private void displaySearchField() {
        if( null != searchpanel || !isQuickSearchAllowed())
            return;

        TreeView previousSearchField = lastSearchField.get();
        if (previousSearchField != null && previousSearchField != this) {
            previousSearchField.removeSearchField();
        }

        JViewport vp = getViewport();
        originalScrollMode = vp.getScrollMode();
        vp.setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
        searchTextField.setFont(tree.getFont());
        prepareSearchPanel();
        add(searchpanel);
        invalidate();
        revalidate();
        repaint();
        searchTextField.requestFocus();

        lastSearchField = new WeakReference<TreeView>(this);
    }

    /**
     * Removes the search field from the tree.
     */
    private void removeSearchField() {
        if( null == searchpanel )
            return;

        if (tree.getSelectionPaths() == null && origSelectionPaths != null) {
            tree.setSelectionPaths(origSelectionPaths);
        }

        remove(searchpanel);
        searchpanel = null;
        origSelectionPaths = null;
        getViewport().setScrollMode(originalScrollMode);
        invalidate();
        revalidate();
        repaint();
    }

    private class ExplorerScrollPaneLayout extends ScrollPaneLayout {

        @Override
        public void layoutContainer( Container parent ) {
            super.layoutContainer(parent);
            if( null != searchPanel && searchPanel.isVisible() ) {
                Insets innerInsets = getInnerInsets();
                Dimension prefSize = searchPanel.getPreferredSize();
                searchPanel.setBounds(innerInsets.left, parent.getHeight()-innerInsets.bottom-prefSize.height,
                        parent.getWidth()-innerInsets.left-innerInsets.right, prefSize.height);
            }
        }
    }

    private final class ExplorerTree extends JTree implements Autoscroll, QuickSearch.Callback {
        AutoscrollSupport support;
        private String maxPrefix;
        int SEARCH_FIELD_SPACE = 3;
        private boolean firstPaint = true;
        /** The last search searchResults */
        private List<TreePath> searchResults = new ArrayList<TreePath>();
        /** The last selected index from the search searchResults. */
        private int currentSelectionIndex;
        private String lastSearchText;


        ExplorerTree(TreeModel model) {

            new GuardedActions(3, fe);
        }

        @Override
        protected void processKeyEvent(KeyEvent e) {
            qs.processKeyEvent(e);
            if (!e.isConsumed()) {
                super.processKeyEvent(e);
            }
        }
        
        private void repaintSelection() {
            int first = getSelectionModel().getMinSelectionRow();
            int last = getSelectionModel().getMaxSelectionRow();


        private void setupSearch() {
            // Remove the default key listeners
//            KeyListener[] keyListeners = getListeners(KeyListener.class);
//
//            for (int i = 0; i < keyListeners.length; i++) {
//                removeKeyListener(keyListeners[i]);
//            }
            
            qs = QuickSearch.attach(TreeView.this, searchConstraints, this);
        }

        @Override
        public void quickSearchUpdate(String searchText) {
            lastSearchText = searchText;
            currentSelectionIndex = 0;
            searchResults.clear();
            maxPrefix = null;

            String text = searchText.toUpperCase();

            if (text.length() > 0) {
                searchResults = doSearch(text);
            }
            displaySearchResult();
        }

        @Override
        public void showNextSelection(boolean forward) {
            if (forward) {
                currentSelectionIndex++;
            } else {
                currentSelectionIndex--;
            }
            displaySearchResult();
        }

        @Override
        public String findMaxPrefix(String prefix) {
            return maxPrefix;
        }

        @Override
        public void quickSearchConfirmed() {
            TreePath selectedTPath = getSelectionPath();
            if (selectedTPath != null) {
                TreeNode selectedTNode = (TreeNode) selectedTPath.getLastPathComponent();
                Node selectedNode = Visualizer.findNode(selectedTNode);
                performPreferredActionOnNodes(new Node[] { selectedNode });
            }
            origSelectionPaths = null;
            searchResults.clear();
            lastSearchText = null;
        }

        @Override
        public void quickSearchCanceled() {
            origSelectionPaths = null;
            searchResults.clear();
            lastSearchText = null;
        }

                        final KeyStroke stroke = KeyStroke.getKeyStrokeForEvent(e);
                        origSelectionPaths = getSelectionPaths();
                        if (origSelectionPaths != null && origSelectionPaths.length == 0) {
                            origSelectionPaths = null;
                        }
                        searchTextField.setText(String.valueOf(stroke.getKeyChar()));

                        displaySearchField();
                        e.consume();
                    }
                }
            );
            if(isQuickSearchAllowed()){
                addKeyListener(quickSearchKeyAdapter);
            }
            // Create a the "multi-event" listener for the text field. Instead of
            // adding separate instances of each needed listener, we're using a
            // class which implements them all. This approach is used in order 
            // to avoid the creation of 4 instances which takes some time
            SearchFieldListener searchFieldListener = new SearchFieldListener();
            searchTextField.addKeyListener(searchFieldListener);
            searchTextField.addFocusListener(searchFieldListener);
            searchTextField.getDocument().addDocumentListener(searchFieldListener);
        }
        
        private List<TreePath> doSearch(String prefix) {
            List<TreePath> results = new ArrayList<TreePath>();
            Set<TreePath> resSet = new HashSet<TreePath>();

            while (true) {
                startIndex = startIndex % size;

                SubstringSearchResult substringSearchResult = getNextSubstringMatch(prefix, startIndex, true);
                TreePath path = substringSearchResult != null? substringSearchResult.treePath: null;

                if ((path != null) && !resSet.contains(path)) {

                            maxPrefix = elementName;
                        }

                        maxPrefix = QuickSearch.findMaxPrefix(maxPrefix, elementName, true);
                    }
                    // try next element
                    startIndex++;

            return results;
        }

        private String findMaxPrefix(String str1, String str2) {
            String res = null;

            for (int i = 0; str1.regionMatches(true, 0, str2, 0, i); i++) {
                res = str1.substring(0, i);
            }

            return res;
        }
        
        /**
         * Copied and adapted from JTree.getNextMatch(...).
         * 

         *         and the index of the first occurrence of the substring in TreePath.
         */
        private SubstringSearchResult getNextSubstringMatch(
                String substring, int startingRow, boolean forward) {

            int max = getRowCount();
            if (substring == null) {


            // start search from the next/previous element froom the 
            // selected element
            int increment = (forward) ? 1 : -1;
            int row = startingRow;
            do {
                TreePath path = getPathForRow(row);

            return null;
        }

        private void displaySearchResult() {
            int sz = searchResults.size();

            if (sz > 0) {
                if (currentSelectionIndex < 0) {
                    currentSelectionIndex = sz - 1;
                } else if (currentSelectionIndex >= sz) {
                    currentSelectionIndex = 0;
                }

                TreePath path = searchResults.get(currentSelectionIndex);
                setSelectionPath(path);
                scrollPathToVisible(path);
            } else {
                if (lastSearchText.isEmpty() && origSelectionPaths != null) {
                    setSelectionPaths(origSelectionPaths);
                    scrollPathToVisible(origSelectionPaths[0]);
                } else {
                    clearSelection();
                }
            }
        }

        /** notify the Component to autoscroll */
        @Override
        public void autoscroll(Point cursorLoc) {

            }
        }

        private class SearchFieldListener extends KeyAdapter implements DocumentListener, FocusListener {
            /** The last search results */
            private List<TreePath> results = new ArrayList<TreePath>();

            /** The last selected index from the search results. */
            private int currentSelectionIndex;

            SearchFieldListener() {
            }

            @Override
            public void changedUpdate(DocumentEvent e) {
                searchForNode();
            }

            @Override
            public void insertUpdate(DocumentEvent e) {
                searchForNode();
            }

            @Override
            public void removeUpdate(DocumentEvent e) {
                searchForNode();
            }

            @Override
            public void keyPressed(KeyEvent e) {
                int keyCode = e.getKeyCode();

                if (keyCode == KeyEvent.VK_ESCAPE) {
                    removeSearchField();
                    ExplorerTree.this.requestFocus();
                } else if (keyCode == KeyEvent.VK_UP || (keyCode == KeyEvent.VK_F3 && e.isShiftDown())) {
                    currentSelectionIndex--;
                    displaySearchResult();

                    // Stop processing the event here. Otherwise it's dispatched
                    // to the tree too (which scrolls)
                    e.consume();
                } else if (keyCode == KeyEvent.VK_DOWN || keyCode == KeyEvent.VK_F3) {
                    currentSelectionIndex++;
                    displaySearchResult();

                    // Stop processing the event here. Otherwise it's dispatched
                    // to the tree too (which scrolls)
                    e.consume();
                } else if (keyCode == KeyEvent.VK_TAB) {
                    if (maxPrefix != null) {
                        searchTextField.setText(maxPrefix);
                    }

                    e.consume();
                } else if (keyCode == KeyEvent.VK_ENTER) {
                    removeSearchField();

                    // bugfix #39607, don't expand selected node when default action invoked
                    TreePath selectedTPath = getSelectionPath();

                    if (selectedTPath != null) {
                        TreeNode selectedTNode = (TreeNode) selectedTPath.getLastPathComponent();
                        Node selectedNode = Visualizer.findNode(selectedTNode);

                        if (
                            (selectedNode.getPreferredAction() == null) ||
                                !selectedNode.getPreferredAction().isEnabled()
                        ) {
                            expandPath(getSelectionPath());
                        }
                    }

                    ExplorerTree.this.requestFocus();
                    ExplorerTree.this.dispatchEvent(e);
                }
            }

            /** Searches for a node in the tree. */
            private void searchForNode() {
                currentSelectionIndex = 0;
                results.clear();
                maxPrefix = null;

                String text = searchTextField.getText().toUpperCase();

                if (text.length() > 0) {
                    results = doSearch(text);
                }
                displaySearchResult();
            }

            private void displaySearchResult() {
                int sz = results.size();

                if (sz > 0) {
                    if (currentSelectionIndex < 0) {
                        currentSelectionIndex = sz - 1;
                    } else if (currentSelectionIndex >= sz) {
                        currentSelectionIndex = 0;
                    }

                    TreePath path = results.get(currentSelectionIndex);
                    setSelectionPath(path);
                    scrollPathToVisible(path);
                } else {
                    if (searchTextField.getText().length() == 0 && origSelectionPaths != null) {
                        setSelectionPaths(origSelectionPaths);
                        scrollPathToVisible(origSelectionPaths[0]);
                    } else {
                        clearSelection();
                    }
                }
            }

            @Override
            public void focusGained(FocusEvent e) {
                // make sure nothing is selected
                searchTextField.select(1, 1);
            }

            @Override
            public void focusLost(FocusEvent e) {
                results.clear();
                removeSearchField();
            }
        }

        private class AccessibleExplorerTree extends JTree.AccessibleJTree {
            AccessibleExplorerTree() {
            }

Lines 219-227 Link Here

(-)a/openide.explorer/test/unit/src/org/openide/explorer/view/TreeViewQuickSearchTest.java (-2 / +2 lines)
219		219
220	if (phase[0] != 0) {	220	if (phase[0] != 0) {
221	if (btv.isQuickSearchAllowed()) {	221	if (btv.isQuickSearchAllowed()) {
222	assertNotNull("Quick Search enabled ", btv.searchpanel);	222	assertNotNull("Quick Search enabled ", btv.getSearchPanel());
223	} else {	223	} else {
224	assertNull("Quick Search disable", btv.searchpanel);	224	assertNull("Quick Search disable", btv.getSearchPanel());
225	}	225	}
226	}	226	}
227	}	227	}

Return to bug 208794

Lines 88-93 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/OutlineView.java (-33 / +63 lines)
88	import javax.swing.BorderFactory;	88	import javax.swing.BorderFactory;
89	import javax.swing.InputMap;	89	import javax.swing.InputMap;
90	import javax.swing.JComponent;	90	import javax.swing.JComponent;
		91	import javax.swing.JMenu;
91	import javax.swing.JPopupMenu;	92	import javax.swing.JPopupMenu;
92	import javax.swing.JScrollBar;	93	import javax.swing.JScrollBar;
93	import javax.swing.JScrollPane;	94	import javax.swing.JScrollPane;
Lines 132-137 Link Here
132	import org.netbeans.swing.outline.TreePathSupport;	133	import org.netbeans.swing.outline.TreePathSupport;
133	import org.openide.awt.Mnemonics;	134	import org.openide.awt.Mnemonics;
134	import org.openide.awt.MouseUtils;	135	import org.openide.awt.MouseUtils;
		136	import org.openide.awt.QuickSearch;
135	import org.openide.explorer.ExplorerManager;	137	import org.openide.explorer.ExplorerManager;
136	import org.openide.explorer.ExplorerUtils;	138	import org.openide.explorer.ExplorerUtils;
137	import org.openide.explorer.propertysheet.PropertyPanel;	139	import org.openide.explorer.propertysheet.PropertyPanel;
Lines 233-241 Link Here
233	rowModel = new PropertiesRowModel();	235	rowModel = new PropertiesRowModel();
234	model = createOutlineModel(treeModel, rowModel, nodesColumnLabel);	236	model = createOutlineModel(treeModel, rowModel, nodesColumnLabel);
235	outline = new OutlineViewOutline(model, rowModel);	237	outline = new OutlineViewOutline(model, rowModel);
236	quickSearch = QuickSearch.attach(this, searchConstraints);	238	TableQuickSearchSupport tqss = outline.createDefaultTableQuickSearchSupport();
237	TableQuickSearchSupport tqss = new TableQuickSearchSupport(outline, outline, outline.qss);	239	attachQuickSearch(tqss, false, tqss.createSearchPopupMenu());
238	quickSearch.addQuickSearchListener(tqss);
239	outline.addKeyListener(new KeyListener() {	240	outline.addKeyListener(new KeyListener() {
240	@Override	241	@Override
241	public void keyTyped(KeyEvent e) {	242	public void keyTyped(KeyEvent e) {
Lines 250-256 Link Here
250	quickSearch.processKeyEvent(e);	251	quickSearch.processKeyEvent(e);
251	}	252	}
252	});	253	});
253	quickSearch.setPopupMenu(tqss.createSearchPopupMenu());
254	rowModel.setOutline(outline);	254	rowModel.setOutline(outline);
255	outline.setRenderDataProvider(new NodeRenderDataProvider(outline));	255	outline.setRenderDataProvider(new NodeRenderDataProvider(outline));
256	SheetCell tableCell = new SheetCell.OutlineSheetCell(outline);	256	SheetCell tableCell = new SheetCell.OutlineSheetCell(outline);
Lines 316-321 Link Here
316		316
317	initializeTreeScrollSupport();	317	initializeTreeScrollSupport();
318	}	318	}
		319
		320	private void attachQuickSearch(QuickSearch.Callback callback, boolean asynchronous, JMenu popup) {
		321	if (quickSearch != null) {
		322	quickSearch.detach();
		323	}
		324	quickSearch = QuickSearch.attach(this, searchConstraints, callback, asynchronous, popup);
		325	}
319		326
320	@Override	327	@Override
321	public void add(Component comp, Object constraints) {	328	public void add(Component comp, Object constraints) {
Lines 683-704 Link Here
683	/**	690	/**
684	* Test whether the quick search feature is enabled or not.	691	* Test whether the quick search feature is enabled or not.
685	* Default is enabled (true).	692	* Default is enabled (true).
686	* @since	693	* @since 6.43
687	* @return <code>true</code> if quick search feature is enabled, <code>false</code> otherwise.	694	* @return true if quick search feature is enabled, false otherwise.
688	*/	695	*/
689	/public/ boolean isQuickSearchAllowed() {	696	public boolean isQuickSearchAllowed() {
690	return quickSearch.isEnabled();	697	return quickSearch.isEnabled();
691	}	698	}
692		699
693	/**	700	/**
694	* Set whether the quick search feature is enabled or not.	701	* Set whether the quick search feature is enabled or not.
695	* @since	702	* @since 6.43
696	* @param allowedQuickSearch <code>true</code> if quick search shall be enabled	703	* @param allowedQuickSearch <code>true</code> if quick search shall be enabled
697	*/	704	*/
698	/public/ void setQuickSearchAllowed(boolean allowedQuickSearch) {	705	public void setQuickSearchAllowed(boolean allowedQuickSearch) {
699	quickSearch.setEnabled(allowedQuickSearch);	706	quickSearch.setEnabled(allowedQuickSearch);
700	}	707	}
701		708
		709	/**
		710	* Set a quick search filter.
		711	* @param quickSearchTableFilter The quick search filter
		712	* @param asynchronous
		713	* @since 6.43
		714	*/
		715	public void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter, boolean asynchronous) {
		716	TableQuickSearchSupport tqss = outline.createTableQuickSearchSupport(quickSearchTableFilter);
		717	attachQuickSearch(tqss, asynchronous, tqss.createSearchPopupMenu());
		718	}
		719
702	/** Initializes the component and lookup explorer manager.	720	/** Initializes the component and lookup explorer manager.
703	*/	721	*/
704	@Override	722	@Override
Lines 1327-1333 Link Here
1327	* Extension of the ETable that allows adding a special comparator	1345	* Extension of the ETable that allows adding a special comparator
1328	* for sorting the rows.	1346	* for sorting the rows.
1329	*/	1347	*/
1330	static class OutlineViewOutline extends Outline implements TableQuickSearchSupport.StringValuedTable {	1348	static class OutlineViewOutline extends Outline {
1331	private final PropertiesRowModel rowModel;	1349	private final PropertiesRowModel rowModel;
1332	private static final String COLUMNS_SELECTOR_HINT = "ColumnsSelectorHint"; // NOI18N	1350	private static final String COLUMNS_SELECTOR_HINT = "ColumnsSelectorHint"; // NOI18N
1333	private static final String COPY_ACTION_DELEGATE = "Outline Copy Action Delegate "; // NOI18N	1351	private static final String COPY_ACTION_DELEGATE = "Outline Copy Action Delegate "; // NOI18N
Lines 1406-1439 Link Here
1406	}	1424	}
1407	return null;	1425	return null;
1408	}	1426	}
		1427
		1428	private TableQuickSearchSupport createDefaultTableQuickSearchSupport() {
		1429	return new TableQuickSearchSupport(this, new DefaultQuickSearchTableFilter(), qss);
		1430	}
1409		1431
1410	@Override	1432	private TableQuickSearchSupport createTableQuickSearchSupport(QuickSearchTableFilter quickSearchTableFilter) {
1411	public String getStringValueAt(int row, int col) {	1433	return new TableQuickSearchSupport(this, quickSearchTableFilter, qss);
1412	Object value = transformValue(getValueAt(row, col));	1434	}
1413	String str;	1435
1414	if (value instanceof Property) {	1436	private final class DefaultQuickSearchTableFilter implements QuickSearchTableFilter {
1415	Property p = (Property) value;	1437
1416	Object v = null;	1438	@Override
1417	try {	1439	public String getStringValueAt(int row, int col) {
1418	v = p.getValue();	1440	Object value = transformValue(getValueAt(row, col));
1419	} catch (IllegalAccessException ex) {	1441	String str;
1420	} catch (InvocationTargetException ex) {	1442	if (value instanceof Property) {
1421	}	1443	Property p = (Property) value;
1422	if (v instanceof String) {	1444	Object v = null;
1423	str = (String) v;	1445	try {
		1446	v = p.getValue();
		1447	} catch (IllegalAccessException ex) {
		1448	} catch (InvocationTargetException ex) {
		1449	}
		1450	if (v instanceof String) {
		1451	str = (String) v;
		1452	} else {
		1453	str = null;
		1454	}
		1455	} else if (value instanceof VisualizerNode) {
		1456	str = ((VisualizerNode) value).getDisplayName();
		1457	} else if (value instanceof Node) {
		1458	str = ((Node) value).getDisplayName();
		1459	} else if (value instanceof String) {
		1460	str = (String) value;
1424	} else {	1461	} else {
1425	str = null;	1462	str = null;
1426	}	1463	}
1427	} else if (value instanceof VisualizerNode) {	1464	return str;
1428	str = ((VisualizerNode) value).getDisplayName();
1429	} else if (value instanceof Node) {
1430	str = ((Node) value).getDisplayName();
1431	} else if (value instanceof String) {
1432	str = (String) value;
1433	} else {
1434	str = null;
1435	}	1465	}
1436	return str;	1466
1437	}	1467	}
1438		1468
1439	private class CopyToClipboardAction implements Action {	1469	private class CopyToClipboardAction implements Action {

Lines 61-67 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TableQuickSearchSupport.java (-19 / +24 lines)
61	import javax.swing.event.ChangeListener;	61	import javax.swing.event.ChangeListener;
62	import javax.swing.table.TableColumn;	62	import javax.swing.table.TableColumn;
63	import javax.swing.table.TableColumnModel;	63	import javax.swing.table.TableColumnModel;
64	import javax.swing.text.Position;	64	import org.openide.awt.QuickSearch;
65	import org.openide.util.NbBundle;	65	import org.openide.util.NbBundle;
66	import org.openide.util.NbPreferences;	66	import org.openide.util.NbPreferences;
67		67
Lines 70-76 Link Here
70	*	70	*
71	* @author Martin Entlicher	71	* @author Martin Entlicher
72	*/	72	*/
73	class TableQuickSearchSupport implements QuickSearch.QuickSearchListener {	73	class TableQuickSearchSupport implements QuickSearch.Callback {
74		74
75	private int quickSearchInitialRow = -1; // The search was initiated here	75	private int quickSearchInitialRow = -1; // The search was initiated here
76	private int quickSearchInitialColumn = -1; // The search was initiated here	76	private int quickSearchInitialColumn = -1; // The search was initiated here
Lines 79-93 Link Here
79	private String lastSearchText;	79	private String lastSearchText;
80		80
81	private JTable table;	81	private JTable table;
82	private StringValuedTable svTable;	82	//private StringValuedTable svTable;
		83	private QuickSearchTableFilter quickSearchTableFilter;
83	private QuickSearchSettings qss;	84	private QuickSearchSettings qss;
84		85
85	TableQuickSearchSupport(JTable table, StringValuedTable svTable, QuickSearchSettings qss) {	86	TableQuickSearchSupport(JTable table, QuickSearchTableFilter quickSearchTableFilter, QuickSearchSettings qss) {
86	this.table = table;	87	this.table = table;
87	this.svTable = svTable;	88	this.quickSearchTableFilter = quickSearchTableFilter;
88	this.qss = qss;	89	this.qss = qss;
89	}	90	}
90		91
		92	public void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter, boolean asynchronous) {
		93	this.quickSearchTableFilter = quickSearchTableFilter;
		94	}
		95
91	@Override	96	@Override
92	public void quickSearchUpdate(String searchText) {	97	public void quickSearchUpdate(String searchText) {
93	lastSearchText = searchText;	98	lastSearchText = searchText;
Lines 103-114 Link Here
103	}	108	}
104	quickSearchLastRow = quickSearchInitialRow;	109	quickSearchLastRow = quickSearchInitialRow;
105	quickSearchLastColumn = quickSearchInitialColumn;	110	quickSearchLastColumn = quickSearchInitialColumn;
106	doSearch(searchText, Position.Bias.Forward);	111	doSearch(searchText, true);
107	}	112	}
108		113
109	@Override	114	@Override
110	public void showNextSelection(Position.Bias bias) {	115	public void showNextSelection(boolean forward) {
111	if (bias == Position.Bias.Forward) {	116	if (forward) {
112	if (++quickSearchLastColumn >= table.getColumnCount()) {	117	if (++quickSearchLastColumn >= table.getColumnCount()) {
113	quickSearchLastColumn = 0;	118	quickSearchLastColumn = 0;
114	if (++quickSearchLastRow >= table.getRowCount()) {	119	if (++quickSearchLastRow >= table.getRowCount()) {
Lines 116-122 Link Here
116	}	121	}
117	}	122	}
118	}	123	}
119	doSearch(lastSearchText, bias);	124	doSearch(lastSearchText, forward);
120	}	125	}
121		126
122	@Override	127	@Override
Lines 134-140 Link Here
134	String maxPrefix = null;	139	String maxPrefix = null;
135	for (int row = row1; row < row2; row++) {	140	for (int row = row1; row < row2; row++) {
136	for (int col = col1; col < col2; col++) {	141	for (int col = col1; col < col2; col++) {
137	String str = svTable.getStringValueAt(row, col);	142	String str = quickSearchTableFilter.getStringValueAt(row, col);
138	String strUp;	143	String strUp;
139	if (qss.isMatchCase()) {	144	if (qss.isMatchCase()) {
140	strUp = str;	145	strUp = str;
Lines 145-151 Link Here
145	if (maxPrefix == null) {	150	if (maxPrefix == null) {
146	maxPrefix = str;	151	maxPrefix = str;
147	} else {	152	} else {
148	maxPrefix = QuickSearch.findMaxCommonSubstring(maxPrefix, str, !qss.isMatchCase());	153	maxPrefix = QuickSearch.findMaxPrefix(maxPrefix, str, !qss.isMatchCase());
149	}	154	}
150	}	155	}
151	}	156	}
Lines 170-195 Link Here
170	quickSearchInitialColumn = -1;	175	quickSearchInitialColumn = -1;
171	}	176	}
172		177
173	private void doSearch(String searchText, Position.Bias bias) {	178	private void doSearch(String searchText, boolean forward) {
174	if (!qss.isMatchCase()) {	179	if (!qss.isMatchCase()) {
175	searchText = searchText.toUpperCase();	180	searchText = searchText.toUpperCase();
176	}	181	}
177	int n = table.getRowCount();	182	int n = table.getRowCount();
178	boolean backward = bias == Position.Bias.Backward;	183	//boolean backward = bias == Position.Bias.Backward;
179	int row1 = quickSearchLastRow;	184	int row1 = quickSearchLastRow;
180	int row2 = quickSearchLastRow + n;	185	int row2 = quickSearchLastRow + n;
181	boolean lineStartSearch = true;	186	boolean lineStartSearch = true;
182	Set<String> columnsIgnoredToSearch = qss.getColumnsIgnoredToSearch();	187	Set<String> columnsIgnoredToSearch = qss.getColumnsIgnoredToSearch();
183	do {	188	do {
184	int col1 = quickSearchLastColumn;	189	int col1 = quickSearchLastColumn;
185	int col2 = (backward) ? 0 : table.getColumnCount();	190	int col2 = (forward) ? table.getColumnCount() : 0;
186	for (int row = (backward) ? (row2 - 1) : row1; (backward) ? row >= row1 : row < row2; row = (backward) ? --row : ++row) {	191	for (int row = (forward) ? row1 : (row2 - 1); (forward) ? row < row2 : row >= row1; row = (forward) ? ++row : --row) {
187	for (int col = col1; (backward) ? col >= col2 : col < col2; col = (backward) ? --col : ++col) {	192	for (int col = col1; (forward) ? col < col2 : col >= col2; col = (forward) ? ++col : --col) {
188	String cName = table.getColumnName(col);	193	String cName = table.getColumnName(col);
189	if (columnsIgnoredToSearch.contains(cName)) {	194	if (columnsIgnoredToSearch.contains(cName)) {
190	continue;	195	continue;
191	}	196	}
192	String str = svTable.getStringValueAt(row % n, col);	197	String str = quickSearchTableFilter.getStringValueAt(row % n, col);
193	if (str == null) {	198	if (str == null) {
194	continue;	199	continue;
195	}	200	}
Lines 208-214 Link Here
208	}	213	}
209	}	214	}
210	}	215	}
211	col1 = (backward) ? table.getColumnCount() - 1 : 0;	216	col1 = (forward) ? 0 : table.getColumnCount() - 1;
212	}	217	}
213	lineStartSearch = !lineStartSearch;	218	lineStartSearch = !lineStartSearch;
214	} while (!lineStartSearch);	219	} while (!lineStartSearch);
Lines 234-240 Link Here
234	return TableQuickSearchSupport.getSearchPopupMenu(qss, table.getColumnModel(), new ActionListener() {	239	return TableQuickSearchSupport.getSearchPopupMenu(qss, table.getColumnModel(), new ActionListener() {
235	@Override	240	@Override
236	public void actionPerformed(ActionEvent e) {	241	public void actionPerformed(ActionEvent e) {
237	doSearch(lastSearchText, Position.Bias.Forward);	242	doSearch(lastSearchText, true);
238	}	243	}
239	});	244	});
240	}	245	}

Lines 87-93 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TreeTable.java (-21 / +31 lines)
87	*	87	*
88	* @author Jan Rojcek	88	* @author Jan Rojcek
89	*/	89	*/
90	class TreeTable extends JTable implements Runnable, TableQuickSearchSupport.StringValuedTable {	90	class TreeTable extends JTable implements Runnable {
91	/** Action key for up/down focus action */	91	/** Action key for up/down focus action */
92	private static final String ACTION_FOCUS_NEXT = "focusNext"; //NOI18N	92	private static final String ACTION_FOCUS_NEXT = "focusNext"; //NOI18N
93	private static Color unfocusedSelBg = null;	93	private static Color unfocusedSelBg = null;
Lines 337-367 Link Here
337	QuickSearchSettings getQuickSearchSettings() {	337	QuickSearchSettings getQuickSearchSettings() {
338	return qss;	338	return qss;
339	}	339	}
		340
		341	private QuickSearchTableFilter qstf = new DefaultQuickSearchTableFilter();
		342
		343	QuickSearchTableFilter getQuickSearchTableFilter() {
		344	return qstf;
		345	}
340		346
341	@Override	347	private final class DefaultQuickSearchTableFilter implements QuickSearchTableFilter {
342	public String getStringValueAt(int row, int col) {	348
343	Object value = getValueAt(row, col);	349	@Override
344	String str;	350	public String getStringValueAt(int row, int col) {
345	if (value instanceof Property) {	351	Object value = getValueAt(row, col);
346	Property p = (Property) value;	352	String str;
347	Object v = null;	353	if (value instanceof Property) {
348	try {	354	Property p = (Property) value;
349	v = p.getValue();	355	Object v = null;
350	} catch (IllegalAccessException ex) {	356	try {
351	} catch (InvocationTargetException ex) {	357	v = p.getValue();
352	}	358	} catch (IllegalAccessException ex) {
353	if (v instanceof String) {	359	} catch (InvocationTargetException ex) {
354	str = (String) v;	360	}
		361	if (v instanceof String) {
		362	str = (String) v;
		363	} else {
		364	str = null;
		365	}
		366	} else if (value instanceof VisualizerNode) {
		367	str = ((VisualizerNode) value).getDisplayName();
		368	//str = Visualizer.findNode(value).getDisplayName();
355	} else {	369	} else {
356	str = null;	370	str = null;
357	}	371	}
358	} else if (value instanceof VisualizerNode) {	372	return str;
359	str = ((VisualizerNode) value).getDisplayName();
360	//str = Visualizer.findNode(value).getDisplayName();
361	} else {
362	str = null;
363	}	373	}
364	return str;	374
365	}	375	}
366		376
367	private class GuardedActions implements Mutex.Action<Object> {	377	private class GuardedActions implements Mutex.Action<Object> {

Lines 77-82 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TreeTableView.java (-4 / +3 lines)
77	import javax.swing.plaf.metal.MetalScrollBarUI;	77	import javax.swing.plaf.metal.MetalScrollBarUI;
78	import javax.swing.table.*;	78	import javax.swing.table.*;
79	import javax.swing.tree.*;	79	import javax.swing.tree.*;
		80	import org.openide.awt.QuickSearch;
80	import org.openide.explorer.view.TreeView.PopupAdapter;	81	import org.openide.explorer.view.TreeView.PopupAdapter;
81	import org.openide.explorer.view.TreeView.PopupSupport;	82	import org.openide.explorer.view.TreeView.PopupSupport;
82	import org.openide.explorer.view.TreeView.TreePropertyListener;	83	import org.openide.explorer.view.TreeView.TreePropertyListener;
Lines 500-508 Link Here
500	TreeTable tt = new TreeTable(treeModel, tableModel);	501	TreeTable tt = new TreeTable(treeModel, tableModel);
501	treeTable = tt;	502	treeTable = tt;
502	tree = ((TreeTable) treeTable).getTree();	503	tree = ((TreeTable) treeTable).getTree();
503	quickSearch = QuickSearch.attach(this, searchConstraints);	504	TableQuickSearchSupport tqss = new TableQuickSearchSupport(tt, tt.getQuickSearchTableFilter(), tt.getQuickSearchSettings());
504	TableQuickSearchSupport tqss = new TableQuickSearchSupport(tt, tt, tt.getQuickSearchSettings());	505	quickSearch = QuickSearch.attach(this, searchConstraints, tqss, tqss.createSearchPopupMenu());
505	quickSearch.addQuickSearchListener(tqss);
506	tt.addKeyListener(new KeyListener() {	506	tt.addKeyListener(new KeyListener() {
507	@Override	507	@Override
508	public void keyTyped(KeyEvent e) {	508	public void keyTyped(KeyEvent e) {
Lines 517-523 Link Here
517	quickSearch.processKeyEvent(e);	517	quickSearch.processKeyEvent(e);
518	}	518	}
519	});	519	});
520	quickSearch.setPopupMenu(tqss.createSearchPopupMenu());
521		520
522	defaultHeaderRenderer = treeTable.getTableHeader().getDefaultRenderer();	521	defaultHeaderRenderer = treeTable.getTableHeader().getDefaultRenderer();
523	treeTable.getTableHeader().setDefaultRenderer(new SortingHeaderRenderer());	522	treeTable.getTableHeader().setDefaultRenderer(new SortingHeaderRenderer());

Lines 50-55 Link Here

(-)a/openide.explorer/apichanges.xml (+14 lines)
50	<apidef name="explorer">Explorer API</apidef>	50	<apidef name="explorer">Explorer API</apidef>
51	</apidefs>	51	</apidefs>
52	<changes>	52	<changes>
		53	<change id="OutlineView_with_quicksearch">
		54	<api name="explorer"/>
		55	<summary>QuickSearch attached to OutlineView</summary>
		56	<version major="6" minor="43"/>
		57	<date day="29" month="2" year="2012"/>
		58	<author login="mentlicher"/>
		59	<compatibility binary="compatible" source="compatible" deprecation="no" deletion="no" addition="yes"/>
		60	<description>
		61	Added <a href="@TOP@/org/openide/explorer/view/OutlineView.html#getQuickSearch()">OutlineView.getQuickSearch()</a>
		62	method to get and control quick search functionality on OutlineView.
		63	</description>
		64	<class package="org.openide.explorer.view" name="OutlineView"/>
		65	<issue number="110686"/>
		66	</change>
53	<change id="PropertyEnv.create">	67	<change id="PropertyEnv.create">
54	<api name="explorer"/>	68	<api name="explorer"/>
55	<summary>API method for creating a PropertyEnv instance</summary>	69	<summary>API method for creating a PropertyEnv instance</summary>

Added Link Here

(-)6bce66b50582 (+52 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.openide.explorer.view;
43
44	/**
45	*
46	* @author Martin Entlicher
47	*/
48	public interface QuickSearchTableFilter {
49
50	String getStringValueAt(int row, int col);
51
52	}