Attachment #116359 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 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);
        //quickSearch = QuickSearch.attach(this, searchConstraints);
        TableQuickSearchSupport tqss = outline.tqss;
        quickSearch = QuickSearch.attach(this, searchConstraints, tqss, 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);

    }
    
    /**
     * Get the quick search support, that is attached to this view.
     * @return The quick search support.
     * @since 6.43
     * @return <code>true</code> if quick search feature is enabled, <code>false</code> otherwise.
     */
    public final QuickSearch getQuickSearch() {
        return quickSearch;
    }
    
    /**
     * Set a quick search filter.
     * @param quickSearchTableFilter The quick search filter
     * @since 6.43
     */
    public void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter) {
        outline.setQuickSearchTableFilter(quickSearchTableFilter);
    }
    
    /** 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

        private ExplorerManager manager;
        //private int maxRowWidth;
        private QuickSearchSettings qss = new QuickSearchSettings();
        private TableQuickSearchSupport tqss;

        public OutlineViewOutline(final OutlineModel mdl, PropertiesRowModel rowModel) {
            super(mdl);

            getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ctrlSpace, "invokeCustomEditor"); //NOI18N
            Action invokeCustomEditorAction = new InvokeCustomEditorAction(ctrlSpaceActionBind);
            getActionMap().put("invokeCustomEditor", invokeCustomEditorAction);
            tqss = new TableQuickSearchSupport(this, new DefaultQuickSearchTableFilter(), qss);
        }
        
        private void removeDefaultCutCopyPaste(InputMap map) {

            }
            return null;
        }
        
        public final void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter) {
            tqss.setQuickSearchTableFilter(quickSearchTableFilter);
        }

        private final class DefaultQuickSearchTableFilter implements QuickSearchTableFilter {

            @Override
            public boolean asynchronous() {
                return false;
            }

            @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 {
    
    boolean asynchronous();
    
    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) {
        this.quickSearchTableFilter = quickSearchTableFilter;
    }

    @Override
    public boolean asynchronous() {
        return quickSearchTableFilter.asynchronous();
    }
    
    @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 boolean asynchronous() {
            return false;
        }

        @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 boolean asynchronous() {
            return false;

            // create new key listeners
            quickSearchKeyAdapter = (
                new KeyAdapter() {
                @Override
                    public void keyTyped(KeyEvent e) {
                        int modifiers = e.getModifiers();
                        int keyCode = e.getKeyCode();
                        char c = e.getKeyChar();

                        //#43617 - don't eat + and -
                        //#98634 - and all its duplicates dont't react to space
                        if ((c == '+') || (c == '-') || (c==' ')) return; // NOI18N

                        if (((modifiers > 0) && (modifiers != KeyEvent.SHIFT_MASK)) || e.isActionKey()) {
                            return;
                        }

                        if (Character.isISOControl(c) ||
                              (keyCode == KeyEvent.VK_SHIFT) ||
			      (keyCode == KeyEvent.VK_ESCAPE)) return;

                        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);
        }
        
        @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;
        }

        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 132-137 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/OutlineView.java (-40 / +56 lines)
132	import org.netbeans.swing.outline.TreePathSupport;	132	import org.netbeans.swing.outline.TreePathSupport;
133	import org.openide.awt.Mnemonics;	133	import org.openide.awt.Mnemonics;
134	import org.openide.awt.MouseUtils;	134	import org.openide.awt.MouseUtils;
		135	import org.openide.awt.QuickSearch;
135	import org.openide.explorer.ExplorerManager;	136	import org.openide.explorer.ExplorerManager;
136	import org.openide.explorer.ExplorerUtils;	137	import org.openide.explorer.ExplorerUtils;
137	import org.openide.explorer.propertysheet.PropertyPanel;	138	import org.openide.explorer.propertysheet.PropertyPanel;
Lines 233-241 Link Here
233	rowModel = new PropertiesRowModel();	234	rowModel = new PropertiesRowModel();
234	model = createOutlineModel(treeModel, rowModel, nodesColumnLabel);	235	model = createOutlineModel(treeModel, rowModel, nodesColumnLabel);
235	outline = new OutlineViewOutline(model, rowModel);	236	outline = new OutlineViewOutline(model, rowModel);
236	quickSearch = QuickSearch.attach(this, searchConstraints);	237	//quickSearch = QuickSearch.attach(this, searchConstraints);
237	TableQuickSearchSupport tqss = new TableQuickSearchSupport(outline, outline, outline.qss);	238	TableQuickSearchSupport tqss = outline.tqss;
238	quickSearch.addQuickSearchListener(tqss);	239	quickSearch = QuickSearch.attach(this, searchConstraints, tqss, tqss.createSearchPopupMenu());
		240	//quickSearch.addQuickSearchListener(tqss);
239	outline.addKeyListener(new KeyListener() {	241	outline.addKeyListener(new KeyListener() {
240	@Override	242	@Override
241	public void keyTyped(KeyEvent e) {	243	public void keyTyped(KeyEvent e) {
Lines 250-256 Link Here
250	quickSearch.processKeyEvent(e);	252	quickSearch.processKeyEvent(e);
251	}	253	}
252	});	254	});
253	quickSearch.setPopupMenu(tqss.createSearchPopupMenu());	255	//quickSearch.setPopupMenu(tqss.createSearchPopupMenu());
254	rowModel.setOutline(outline);	256	rowModel.setOutline(outline);
255	outline.setRenderDataProvider(new NodeRenderDataProvider(outline));	257	outline.setRenderDataProvider(new NodeRenderDataProvider(outline));
256	SheetCell tableCell = new SheetCell.OutlineSheetCell(outline);	258	SheetCell tableCell = new SheetCell.OutlineSheetCell(outline);
Lines 681-704 Link Here
681	}	683	}
682		684
683	/**	685	/**
684	* Test whether the quick search feature is enabled or not.	686	* Get the quick search support, that is attached to this view.
685	* Default is enabled (true).	687	* @return The quick search support.
686	* @since	688	* @since 6.43
687	* @return <code>true</code> if quick search feature is enabled, <code>false</code> otherwise.
688	*/	689	*/
689	/public/ boolean isQuickSearchAllowed() {	690	public final QuickSearch getQuickSearch() {
690	return quickSearch.isEnabled();	691	return quickSearch;
691	}	692	}
692		693
693	/**	694	/**
694	* Set whether the quick search feature is enabled or not.	695	* Set a quick search filter.
695	* @since	696	* @param quickSearchTableFilter The quick search filter
696	* @param allowedQuickSearch <code>true</code> if quick search shall be enabled	697	* @since 6.43
697	*/	698	*/
698	/public/ void setQuickSearchAllowed(boolean allowedQuickSearch) {	699	public void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter) {
699	quickSearch.setEnabled(allowedQuickSearch);	700	outline.setQuickSearchTableFilter(quickSearchTableFilter);
700	}	701	}
701		702
702	/** Initializes the component and lookup explorer manager.	703	/** Initializes the component and lookup explorer manager.
703	*/	704	*/
704	@Override	705	@Override
Lines 1327-1333 Link Here
1327	* Extension of the ETable that allows adding a special comparator	1328	* Extension of the ETable that allows adding a special comparator
1328	* for sorting the rows.	1329	* for sorting the rows.
1329	*/	1330	*/
1330	static class OutlineViewOutline extends Outline implements TableQuickSearchSupport.StringValuedTable {	1331	static class OutlineViewOutline extends Outline {
1331	private final PropertiesRowModel rowModel;	1332	private final PropertiesRowModel rowModel;
1332	private static final String COLUMNS_SELECTOR_HINT = "ColumnsSelectorHint"; // NOI18N	1333	private static final String COLUMNS_SELECTOR_HINT = "ColumnsSelectorHint"; // NOI18N
1333	private static final String COPY_ACTION_DELEGATE = "Outline Copy Action Delegate "; // NOI18N	1334	private static final String COPY_ACTION_DELEGATE = "Outline Copy Action Delegate "; // NOI18N
Lines 1345-1350 Link Here
1345	private ExplorerManager manager;	1346	private ExplorerManager manager;
1346	//private int maxRowWidth;	1347	//private int maxRowWidth;
1347	private QuickSearchSettings qss = new QuickSearchSettings();	1348	private QuickSearchSettings qss = new QuickSearchSettings();
		1349	private TableQuickSearchSupport tqss;
1348		1350
1349	public OutlineViewOutline(final OutlineModel mdl, PropertiesRowModel rowModel) {	1351	public OutlineViewOutline(final OutlineModel mdl, PropertiesRowModel rowModel) {
1350	super(mdl);	1352	super(mdl);
Lines 1364-1369 Link Here
1364	getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ctrlSpace, "invokeCustomEditor"); //NOI18N	1366	getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ctrlSpace, "invokeCustomEditor"); //NOI18N
1365	Action invokeCustomEditorAction = new InvokeCustomEditorAction(ctrlSpaceActionBind);	1367	Action invokeCustomEditorAction = new InvokeCustomEditorAction(ctrlSpaceActionBind);
1366	getActionMap().put("invokeCustomEditor", invokeCustomEditorAction);	1368	getActionMap().put("invokeCustomEditor", invokeCustomEditorAction);
		1369	tqss = new TableQuickSearchSupport(this, new DefaultQuickSearchTableFilter(), qss);
1367	}	1370	}
1368		1371
1369	private void removeDefaultCutCopyPaste(InputMap map) {	1372	private void removeDefaultCutCopyPaste(InputMap map) {
Lines 1406-1439 Link Here
1406	}	1409	}
1407	return null;	1410	return null;
1408	}	1411	}
		1412
		1413	public final void setQuickSearchTableFilter(QuickSearchTableFilter quickSearchTableFilter) {
		1414	tqss.setQuickSearchTableFilter(quickSearchTableFilter);
		1415	}
1409		1416
1410	@Override	1417	private final class DefaultQuickSearchTableFilter implements QuickSearchTableFilter {
1411	public String getStringValueAt(int row, int col) {	1418
1412	Object value = transformValue(getValueAt(row, col));	1419	@Override
1413	String str;	1420	public boolean asynchronous() {
1414	if (value instanceof Property) {	1421	return false;
1415	Property p = (Property) value;	1422	}
1416	Object v = null;	1423
1417	try {	1424	@Override
1418	v = p.getValue();	1425	public String getStringValueAt(int row, int col) {
1419	} catch (IllegalAccessException ex) {	1426	Object value = transformValue(getValueAt(row, col));
1420	} catch (InvocationTargetException ex) {	1427	String str;
1421	}	1428	if (value instanceof Property) {
1422	if (v instanceof String) {	1429	Property p = (Property) value;
1423	str = (String) v;	1430	Object v = null;
		1431	try {
		1432	v = p.getValue();
		1433	} catch (IllegalAccessException ex) {
		1434	} catch (InvocationTargetException ex) {
		1435	}
		1436	if (v instanceof String) {
		1437	str = (String) v;
		1438	} else {
		1439	str = null;
		1440	}
		1441	} else if (value instanceof VisualizerNode) {
		1442	str = ((VisualizerNode) value).getDisplayName();
		1443	} else if (value instanceof Node) {
		1444	str = ((Node) value).getDisplayName();
		1445	} else if (value instanceof String) {
		1446	str = (String) value;
1424	} else {	1447	} else {
1425	str = null;	1448	str = null;
1426	}	1449	}
1427	} else if (value instanceof VisualizerNode) {	1450	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	}	1451	}
1436	return str;	1452
1437	}	1453	}
1438		1454
1439	private class CopyToClipboardAction implements Action {	1455	private class CopyToClipboardAction implements Action {

Lines 61-67 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TableQuickSearchSupport.java (-19 / +29 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) {
		93	this.quickSearchTableFilter = quickSearchTableFilter;
		94	}
		95
		96	@Override
		97	public boolean asynchronous() {
		98	return quickSearchTableFilter.asynchronous();
		99	}
		100
91	@Override	101	@Override
92	public void quickSearchUpdate(String searchText) {	102	public void quickSearchUpdate(String searchText) {
93	lastSearchText = searchText;	103	lastSearchText = searchText;
Lines 103-114 Link Here
103	}	113	}
104	quickSearchLastRow = quickSearchInitialRow;	114	quickSearchLastRow = quickSearchInitialRow;
105	quickSearchLastColumn = quickSearchInitialColumn;	115	quickSearchLastColumn = quickSearchInitialColumn;
106	doSearch(searchText, Position.Bias.Forward);	116	doSearch(searchText, true);
107	}	117	}
108		118
109	@Override	119	@Override
110	public void showNextSelection(Position.Bias bias) {	120	public void showNextSelection(boolean forward) {
111	if (bias == Position.Bias.Forward) {	121	if (forward) {
112	if (++quickSearchLastColumn >= table.getColumnCount()) {	122	if (++quickSearchLastColumn >= table.getColumnCount()) {
113	quickSearchLastColumn = 0;	123	quickSearchLastColumn = 0;
114	if (++quickSearchLastRow >= table.getRowCount()) {	124	if (++quickSearchLastRow >= table.getRowCount()) {
Lines 116-122 Link Here
116	}	126	}
117	}	127	}
118	}	128	}
119	doSearch(lastSearchText, bias);	129	doSearch(lastSearchText, forward);
120	}	130	}
121		131
122	@Override	132	@Override
Lines 134-140 Link Here
134	String maxPrefix = null;	144	String maxPrefix = null;
135	for (int row = row1; row < row2; row++) {	145	for (int row = row1; row < row2; row++) {
136	for (int col = col1; col < col2; col++) {	146	for (int col = col1; col < col2; col++) {
137	String str = svTable.getStringValueAt(row, col);	147	String str = quickSearchTableFilter.getStringValueAt(row, col);
138	String strUp;	148	String strUp;
139	if (qss.isMatchCase()) {	149	if (qss.isMatchCase()) {
140	strUp = str;	150	strUp = str;
Lines 145-151 Link Here
145	if (maxPrefix == null) {	155	if (maxPrefix == null) {
146	maxPrefix = str;	156	maxPrefix = str;
147	} else {	157	} else {
148	maxPrefix = QuickSearch.findMaxCommonSubstring(maxPrefix, str, !qss.isMatchCase());	158	maxPrefix = QuickSearch.findMaxPrefix(maxPrefix, str, !qss.isMatchCase());
149	}	159	}
150	}	160	}
151	}	161	}
Lines 170-195 Link Here
170	quickSearchInitialColumn = -1;	180	quickSearchInitialColumn = -1;
171	}	181	}
172		182
173	private void doSearch(String searchText, Position.Bias bias) {	183	private void doSearch(String searchText, boolean forward) {
174	if (!qss.isMatchCase()) {	184	if (!qss.isMatchCase()) {
175	searchText = searchText.toUpperCase();	185	searchText = searchText.toUpperCase();
176	}	186	}
177	int n = table.getRowCount();	187	int n = table.getRowCount();
178	boolean backward = bias == Position.Bias.Backward;	188	//boolean backward = bias == Position.Bias.Backward;
179	int row1 = quickSearchLastRow;	189	int row1 = quickSearchLastRow;
180	int row2 = quickSearchLastRow + n;	190	int row2 = quickSearchLastRow + n;
181	boolean lineStartSearch = true;	191	boolean lineStartSearch = true;
182	Set<String> columnsIgnoredToSearch = qss.getColumnsIgnoredToSearch();	192	Set<String> columnsIgnoredToSearch = qss.getColumnsIgnoredToSearch();
183	do {	193	do {
184	int col1 = quickSearchLastColumn;	194	int col1 = quickSearchLastColumn;
185	int col2 = (backward) ? 0 : table.getColumnCount();	195	int col2 = (forward) ? table.getColumnCount() : 0;
186	for (int row = (backward) ? (row2 - 1) : row1; (backward) ? row >= row1 : row < row2; row = (backward) ? --row : ++row) {	196	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) {	197	for (int col = col1; (forward) ? col < col2 : col >= col2; col = (forward) ? ++col : --col) {
188	String cName = table.getColumnName(col);	198	String cName = table.getColumnName(col);
189	if (columnsIgnoredToSearch.contains(cName)) {	199	if (columnsIgnoredToSearch.contains(cName)) {
190	continue;	200	continue;
191	}	201	}
192	String str = svTable.getStringValueAt(row % n, col);	202	String str = quickSearchTableFilter.getStringValueAt(row % n, col);
193	if (str == null) {	203	if (str == null) {
194	continue;	204	continue;
195	}	205	}
Lines 208-214 Link Here
208	}	218	}
209	}	219	}
210	}	220	}
211	col1 = (backward) ? table.getColumnCount() - 1 : 0;	221	col1 = (forward) ? 0 : table.getColumnCount() - 1;
212	}	222	}
213	lineStartSearch = !lineStartSearch;	223	lineStartSearch = !lineStartSearch;
214	} while (!lineStartSearch);	224	} while (!lineStartSearch);
Lines 234-240 Link Here
234	return TableQuickSearchSupport.getSearchPopupMenu(qss, table.getColumnModel(), new ActionListener() {	244	return TableQuickSearchSupport.getSearchPopupMenu(qss, table.getColumnModel(), new ActionListener() {
235	@Override	245	@Override
236	public void actionPerformed(ActionEvent e) {	246	public void actionPerformed(ActionEvent e) {
237	doSearch(lastSearchText, Position.Bias.Forward);	247	doSearch(lastSearchText, true);
238	}	248	}
239	});	249	});
240	}	250	}

Lines 87-93 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TreeTable.java (-21 / +36 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 boolean asynchronous() {
345	if (value instanceof Property) {	351	return false;
346	Property p = (Property) value;	352	}
347	Object v = null;	353
348	try {	354	@Override
349	v = p.getValue();	355	public String getStringValueAt(int row, int col) {
350	} catch (IllegalAccessException ex) {	356	Object value = getValueAt(row, col);
351	} catch (InvocationTargetException ex) {	357	String str;
352	}	358	if (value instanceof Property) {
353	if (v instanceof String) {	359	Property p = (Property) value;
354	str = (String) v;	360	Object v = null;
		361	try {
		362	v = p.getValue();
		363	} catch (IllegalAccessException ex) {
		364	} catch (InvocationTargetException ex) {
		365	}
		366	if (v instanceof String) {
		367	str = (String) v;
		368	} else {
		369	str = null;
		370	}
		371	} else if (value instanceof VisualizerNode) {
		372	str = ((VisualizerNode) value).getDisplayName();
		373	//str = Visualizer.findNode(value).getDisplayName();
355	} else {	374	} else {
356	str = null;	375	str = null;
357	}	376	}
358	} else if (value instanceof VisualizerNode) {	377	return str;
359	str = ((VisualizerNode) value).getDisplayName();
360	//str = Visualizer.findNode(value).getDisplayName();
361	} else {
362	str = null;
363	}	378	}
364	return str;	379
365	}	380	}
366		381
367	private class GuardedActions implements Mutex.Action<Object> {	382	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>

Line 0 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/QuickSearchTableFilter.java (+54 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	boolean asynchronous();
	51
	52	String getStringValueAt(int row, int col);
	53
	54	}