Attachment #116097 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;

    }
    
    /**
     * 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 whether the quick search feature is enabled or not.
     * @since 
     * @param allowedQuickSearch <code>true</code> if quick search shall be enabled
     */
    /*public*/ void setQuickSearchAllowed(boolean allowedQuickSearch) {
        quickSearch.setEnabled(allowedQuickSearch);
    }

    /** Initializes the component and lookup explorer manager.
     */
    @Override




/*
 * 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;

import java.awt.*;
import java.awt.event.*;
import java.lang.ref.WeakReference;
import java.util.LinkedList;
import java.util.List;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.Position.Bias;

/**
 * Quick search infrastructure
 * 
 * @author Martin Entlicher
 */
class QuickSearch {
    
    private static final String ICON_FIND = "org/openide/explorer/view/find.png";
    private static final String ICON_FIND_WITH_MENU = "org/openide/explorer/view/findMenu.png";
    
    private final JComponent component;
    private final Object constraints;
    private boolean enabled = true;
    private final List<QuickSearchListener> listeners = new LinkedList<QuickSearchListener>();
    private SearchTextField searchTextField;
    private KeyAdapter quickSearchKeyAdapter;
    private JPanel searchPanel;
    private JMenu popupMenu;
    
    private QuickSearch(JComponent component, Object constraints) {
        this.component = component;
        this.constraints = constraints;
        setUpSearch();
    }
    
    public static QuickSearch attach(JComponent component, Object constraints) {
        Object qso = component.getClientProperty(QuickSearch.class.getName());
        if (qso instanceof QuickSearch) {
            return (QuickSearch) qso;
        } else {
            QuickSearch qs = new QuickSearch(component, constraints);
            component.putClientProperty(QuickSearch.class.getName(), qs);
            return qs;
        }
    }
    
    public void detach() {
        setEnabled(false);
        component.putClientProperty(QuickSearch.class.getName(), null);
    }
    
    public boolean isEnabled() {
        return enabled;
    }
    
    public void setEnabled(boolean enabled) {
        if (this.enabled == enabled) {
            return ;
        }
        this.enabled = enabled;
        if (enabled) {
            component.addKeyListener(quickSearchKeyAdapter);
        } else {
            component.removeKeyListener(quickSearchKeyAdapter);
        }
    }
    
    public void addQuickSearchListener(QuickSearchListener qsl) {
        synchronized (listeners) {
            listeners.add(qsl);
        }
    }
    
    public void removeQuickSearchListener(QuickSearchListener qsl) {
        synchronized (listeners) {
            listeners.remove(qsl);
        }
    }
    
    public void setPopupMenu(JMenu popupMenu) {
        this.popupMenu = popupMenu;
    }
    
    public void processKeyEvent(KeyEvent ke) {
        switch(ke.getID()) {
            case KeyEvent.KEY_PRESSED:
                quickSearchKeyAdapter.keyPressed(ke);
                break;
            case KeyEvent.KEY_RELEASED:
                quickSearchKeyAdapter.keyReleased(ke);
                break;
            case KeyEvent.KEY_TYPED:
                quickSearchKeyAdapter.keyTyped(ke);
                break;
        }
    }
    
    private QuickSearchListener[] getQuickSearchListeners() {
        QuickSearchListener[] qsls;
        synchronized (listeners) {
            qsls = listeners.toArray(new QuickSearchListener[] {});
        }
        return qsls;
    }
    
    private void fireQuickSearchUpdate(String searchText) {
        for (QuickSearchListener qsl : getQuickSearchListeners()) {
            qsl.quickSearchUpdate(searchText);
        }
    }
    
    private void fireShowNextSelection(Bias bias) {
        for (QuickSearchListener qsl : getQuickSearchListeners()) {
            qsl.showNextSelection(bias);
        }
    }
    
    private String findMaxPrefix(String prefix) {
        for (QuickSearchListener qsl : getQuickSearchListeners()) {
            prefix = qsl.findMaxPrefix(prefix);
        }
        return prefix;
    }
    
    private void fireQuickSearchConfirmed() {
        for (QuickSearchListener qsl : getQuickSearchListeners()) {
            qsl.quickSearchConfirmed();
        }
    }
    
    private void fireQuickSearchCanceled() {
        for (QuickSearchListener qsl : getQuickSearchListeners()) {
            qsl.quickSearchCanceled();
        }
    }
    
    private void setUpSearch() {
        searchTextField = new SearchTextField();
        // 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);
                    searchTextField.setText(String.valueOf(stroke.getKeyChar()));

                    displaySearchField();
                    e.consume();
                }
            }
        );
        if(isEnabled()){
            component.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 void displaySearchField() {
        if (searchPanel != null || !isEnabled()) {
            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.setOriginalFocusOwner();
        searchTextField.setFont(component.getFont());
        searchPanel = new SearchPanel();
        //JLabel lbl = new JLabel(NbBundle.getMessage(TreeView.class, "LBL_QUICKSEARCH")); //NOI18N
        final JLabel lbl;
        if (popupMenu != null) {
            lbl = new JLabel(org.openide.util.ImageUtilities.loadImageIcon(ICON_FIND_WITH_MENU, false));
            lbl.addMouseListener(new MouseAdapter() {
                @Override
                public void mousePressed(MouseEvent e) {
                    if (e != null && !SwingUtilities.isLeftMouseButton(e)) {
                        return;
                    }
                    JPopupMenu pm = popupMenu.getPopupMenu();
                    pm.show(lbl, 0, lbl.getHeight() - 1);
                }
            });
        } else {
            lbl = new JLabel(org.openide.util.ImageUtilities.loadImageIcon(ICON_FIND, false));
        }
        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));
        //JToggleButton matchCaseButton = new JToggleButton("aA");
        //matchCaseButton.setBorder(BorderFactory.createEmptyBorder(0, 5, 0, 5));
        //searchPanel.add(matchCaseButton);
        if (component instanceof JScrollPane) {
        //    ((JScrollPane) component).getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
        }
        if (constraints == null) {
            component.add(searchPanel);
        } else {
            component.add(searchPanel, constraints);
        }
        component.invalidate();
        component.revalidate();
        component.repaint();
        searchTextField.requestFocus();
    }
    
    private void removeSearchField() {
        if (searchPanel == null) {
            return;
        }
        component.remove(searchPanel);
        searchPanel = null;
        //getViewport().setScrollMode(originalScrollMode);
        component.invalidate();
        component.revalidate();
        component.repaint();
    }
    
    public static String findMaxCommonSubstring(String str1, String str2, boolean ignoreCase) {
        int n1 = str1.length();
        int n2 = str2.length();
        int i = 0;
        if (ignoreCase) {
            for ( ; i < n1 && i < n2; i++) {
                char c1 = Character.toUpperCase(str1.charAt(i));
                char c2 = Character.toUpperCase(str2.charAt(i));
                if (c1 != c2) {
                    break;
                }
            }
        } else {
            for ( ; i < n1 && i < n2; i++) {
                char c1 = str1.charAt(i);
                char c2 = str2.charAt(i);
                if (c1 != c2) {
                    break;
                }
            }
        }
        return str1.substring(0, i);
    }

    public static interface QuickSearchListener {
        
        void quickSearchUpdate(String searchText);
        
        void showNextSelection(Bias bias);
        
        String findMaxPrefix(String prefix);
        
        void quickSearchConfirmed();
        
        void quickSearchCanceled();

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

    /** searchTextField manages focus because it handles VK_ESCAPE key */
    private class SearchTextField extends JTextField {
        
        private WeakReference<Component> originalFocusOwner = new WeakReference<Component>(null);
        
        public SearchTextField() {
        }
        
        void setOriginalFocusOwner() {
            Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
            if (focusOwner != null && component.isAncestorOf(focusOwner)) {
                originalFocusOwner = new WeakReference<Component>(focusOwner);
            } else {
                originalFocusOwner = new WeakReference<Component>(component);
            }
        }
        
        void requestOriginalFocusOwner() {
            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() {
                        Component fo = originalFocusOwner.get();
                        if (fo != null) {
                            fo.requestFocusInWindow();
                        }
                    }
                }
            );
        }
        
        @Override
        public boolean isManagingFocus() {
            return true;
        }

        @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
                requestOriginalFocusOwner();
                fireQuickSearchCanceled();
            } else {
                super.processKeyEvent(ke);
            }
        }
    };
    
    private class SearchFieldListener extends KeyAdapter implements DocumentListener, FocusListener {
        
        private boolean ignoreEvents;

        SearchFieldListener() {
        }

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

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

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

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

            if (keyCode == KeyEvent.VK_ESCAPE) {
                removeSearchField();
                searchTextField.requestOriginalFocusOwner();
                fireQuickSearchCanceled();
                e.consume();
            } else if (keyCode == KeyEvent.VK_UP || (keyCode == KeyEvent.VK_F3 && e.isShiftDown())) {
                fireShowNextSelection(Bias.Backward);
                // 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) {
                fireShowNextSelection(Bias.Forward);
                // Stop processing the event here. Otherwise it's dispatched
                // to the tree too (which scrolls)
                e.consume();
            } else if (keyCode == KeyEvent.VK_TAB) {
                String maxPrefix = findMaxPrefix(searchTextField.getText());
                ignoreEvents = true;
                try {
                    searchTextField.setText(maxPrefix);
                } finally {
                    ignoreEvents = false;
                }

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

                component.requestFocusInWindow();
                e.consume();
            }
        }

        /** Searches for a node in the tree. */
        private void searchForNode() {
            String text = searchTextField.getText();
            fireQuickSearchUpdate(text);
        }

        @Override
        public void focusGained(FocusEvent e) {
            if (e.getSource() == searchTextField) {
                // make sure nothing is selected
                int n = searchTextField.getText().length();
                searchTextField.select(n, n);
            }
        }

        @Override
        public void focusLost(FocusEvent e) {
            if (e.isTemporary()) return ;
            Component oppositeComponent = e.getOppositeComponent();
            if (e.getSource() != searchTextField) {
                ((Component) e.getSource()).removeFocusListener(this);
            }
            if (oppositeComponent instanceof JMenuItem || oppositeComponent instanceof JPopupMenu) {
                oppositeComponent.addFocusListener(this);
                return ;
            }
            if (oppositeComponent == searchTextField) {
                return ;
            }
            removeSearchField();
            fireQuickSearchConfirmed();
        }
    }

}




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


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

        }
        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

                    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;

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

Lines 77-82 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TreeTableView.java (+1 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 133-139 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TreeView.java (-332 / +132 lines)
133	import javax.swing.event.TreeWillExpandListener;	133	import javax.swing.event.TreeWillExpandListener;
134	import javax.swing.plaf.TreeUI;	134	import javax.swing.plaf.TreeUI;
135	import javax.swing.plaf.UIResource;	135	import javax.swing.plaf.UIResource;
136	import javax.swing.text.Position;
137	import javax.swing.tree.ExpandVetoException;	136	import javax.swing.tree.ExpandVetoException;
138	import javax.swing.tree.RowMapper;	137	import javax.swing.tree.RowMapper;
139	import javax.swing.tree.TreeCellEditor;	138	import javax.swing.tree.TreeCellEditor;
Lines 141-146 Link Here
141	import javax.swing.tree.TreeNode;	140	import javax.swing.tree.TreeNode;
142	import javax.swing.tree.TreePath;	141	import javax.swing.tree.TreePath;
143	import javax.swing.tree.TreeSelectionModel;	142	import javax.swing.tree.TreeSelectionModel;
		143	import org.openide.awt.QuickSearch;
		144	import org.openide.awt.QuickSearchListener;
144		145
145		146
146	/**	147	/**
Lines 224-231 Link Here
224	transient private int allowedDropActions = DnDConstants.ACTION_COPY_OR_MOVE \| DnDConstants.ACTION_REFERENCE;	225	transient private int allowedDropActions = DnDConstants.ACTION_COPY_OR_MOVE \| DnDConstants.ACTION_REFERENCE;
225		226
226	/** Quick Search support */	227	/** Quick Search support */
227	transient private boolean allowedQuickSearch = true;	228	transient private QuickSearch qs;
228	transient private KeyAdapter quickSearchKeyAdapter;
229		229
230	/** wait cursor is shown automatically during expanding */	230	/** wait cursor is shown automatically during expanding */
231	transient private boolean autoWaitCursor = true;	231	transient private boolean autoWaitCursor = true;
Lines 454-460 Link Here
454	* @return true if quick search feature is enabled, false otherwise.	454	* @return true if quick search feature is enabled, false otherwise.
455	*/	455	*/
456	public boolean isQuickSearchAllowed() {	456	public boolean isQuickSearchAllowed() {
457	return allowedQuickSearch;	457	return qs.isEnabled();
458	}	458	}
459		459
460	/**	460	/**
Lines 463-477 Link Here
463	* @param allowedQuickSearch <code>true</code> if quick search shall be enabled	463	* @param allowedQuickSearch <code>true</code> if quick search shall be enabled
464	*/	464	*/
465	public void setQuickSearchAllowed(boolean allowedQuickSearch) {	465	public void setQuickSearchAllowed(boolean allowedQuickSearch) {
466	this.allowedQuickSearch = allowedQuickSearch;	466	qs.setEnabled(allowedQuickSearch);
467	if (quickSearchKeyAdapter != null && tree != null) {
468	if (allowedQuickSearch) {
469	tree.addKeyListener(quickSearchKeyAdapter);
470	} else {
471	removeSearchField();
472	tree.removeKeyListener(quickSearchKeyAdapter);
473	}
474	}
475	}	467	}
476		468
477		469
Lines 1683-1693 Link Here
1683	}	1675	}
1684		1676
1685	@Override	1677	@Override
		1678	public void add(Component comp, Object constraints) {
		1679	if (constraints == searchConstraints) {
		1680	searchPanel = comp;
		1681	constraints = null;
		1682	}
		1683	super.add(comp, constraints);
		1684	}
		1685
		1686	@Override
		1687	public void remove(Component comp) {
		1688	if (comp == searchPanel) {
		1689	searchPanel = null;
		1690	}
		1691	super.remove(comp);
		1692	}
		1693
		1694	@Override
1686	public Insets getInsets() {	1695	public Insets getInsets() {
1687	Insets res = getInnerInsets();	1696	Insets res = getInnerInsets();
1688	res = new Insets(res.top, res.left, res.bottom, res.right);	1697	res = new Insets(res.top, res.left, res.bottom, res.right);
1689	if( null != searchpanel && searchpanel.isVisible() ) {	1698	if( null != searchPanel && searchPanel.isVisible() ) {
1690	res.bottom += searchpanel.getPreferredSize().height;	1699	res.bottom += searchPanel.getPreferredSize().height;
1691	}	1700	}
1692	return res;	1701	return res;
1693	}	1702	}
Lines 1701-1830 Link Here
1701	}	1710	}
1702		1711
1703	TreePath[] origSelectionPaths = null;	1712	TreePath[] origSelectionPaths = null;
1704	JPanel searchpanel = null;	1713	private Component searchPanel = null;
1705	// searchTextField manages focus because it handles VK_TAB key	1714	private final Object searchConstraints = new Object();
1706	private JTextField searchTextField = new JTextField() {	1715
1707	@Override	1716	/** Called from tests */
1708	public boolean isManagingFocus() {	1717	Component getSearchPanel() {
1709	return true;	1718	return searchPanel;
1710	}
1711
1712	@Override
1713	public void processKeyEvent(KeyEvent ke) {
1714	//override the default handling so that
1715	//the parent will never receive the escape key and
1716	//close a modal dialog
1717	if (ke.getKeyCode() == KeyEvent.VK_ESCAPE) {
1718	removeSearchField();
1719	ke.consume();
1720
1721	// bugfix #32909, reqest focus when search field is removed
1722	SwingUtilities.invokeLater(
1723	new Runnable() {
1724	//additional bugfix - do focus change later or removing
1725	//the component while it's focused will cause focus to
1726	//get transferred to the next component in the
1727	//parent focusTraversalPolicy after our request
1728	//focus completes, so focus goes into a black hole - Tim
1729	@Override
1730	public void run() {
1731	if( null != tree )
1732	tree.requestFocus();
1733	}
1734	}
1735	);
1736	} else {
1737	super.processKeyEvent(ke);
1738	}
1739	}
1740	};
1741	private int originalScrollMode;
1742
1743	private static class SearchPanel extends JPanel {
1744	public SearchPanel() {
1745	if( ViewUtil.isAquaLaF )
1746	setBorder(BorderFactory.createEmptyBorder(9,6,8,2));
1747	else
1748	setBorder(BorderFactory.createEmptyBorder(2,6,2,2));
1749	setOpaque( true );
1750	}
1751
1752	@Override
1753	protected void paintComponent(Graphics g) {
1754	if( ViewUtil.isAquaLaF && g instanceof Graphics2D ) {
1755	Graphics2D g2d = (Graphics2D) g;
1756	g2d.setPaint( new GradientPaint(0, 0, UIManager.getColor("NbExplorerView.quicksearch.background.top"),
1757	0, getHeight(), UIManager.getColor("NbExplorerView.quicksearch.background.bottom")));//NOI18N
1758	g2d.fillRect(0, 0, getWidth(), getHeight());
1759	g2d.setColor( UIManager.getColor("NbExplorerView.quicksearch.border") ); //NOI18N
1760	g2d.drawLine(0, 0, getWidth(), 0);
1761	} else {
1762	super.paintComponent(g);
1763	}
1764	}
1765	}
1766
1767
1768	private void prepareSearchPanel() {
1769	if( searchpanel == null ) {
1770	searchpanel = new SearchPanel();
1771
1772	JLabel lbl = new JLabel(NbBundle.getMessage(TreeView.class, "LBL_QUICKSEARCH")); //NOI18N
1773	searchpanel.setLayout(new BoxLayout(searchpanel, BoxLayout.X_AXIS));
1774	searchpanel.add(lbl);
1775	searchpanel.add(searchTextField);
1776	lbl.setLabelFor(searchTextField);
1777	searchTextField.setColumns(10);
1778	searchTextField.setMaximumSize(searchTextField.getPreferredSize());
1779	searchTextField.putClientProperty("JTextField.variant", "search"); //NOI18N
1780	lbl.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 5));
1781	}
1782	}
1783
1784	/**
1785	* Adds the search field to the tree.
1786	*/
1787	private void displaySearchField() {
1788	if( null != searchpanel \|\| !isQuickSearchAllowed())
1789	return;
1790
1791	TreeView previousSearchField = lastSearchField.get();
1792	if (previousSearchField != null && previousSearchField != this) {
1793	previousSearchField.removeSearchField();
1794	}
1795
1796	JViewport vp = getViewport();
1797	originalScrollMode = vp.getScrollMode();
1798	vp.setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
1799	searchTextField.setFont(tree.getFont());
1800	prepareSearchPanel();
1801	add(searchpanel);
1802	invalidate();
1803	revalidate();
1804	repaint();
1805	searchTextField.requestFocus();
1806
1807	lastSearchField = new WeakReference<TreeView>(this);
1808	}
1809
1810	/**
1811	* Removes the search field from the tree.
1812	*/
1813	private void removeSearchField() {
1814	if( null == searchpanel )
1815	return;
1816
1817	if (tree.getSelectionPaths() == null && origSelectionPaths != null) {
1818	tree.setSelectionPaths(origSelectionPaths);
1819	}
1820
1821	remove(searchpanel);
1822	searchpanel = null;
1823	origSelectionPaths = null;
1824	getViewport().setScrollMode(originalScrollMode);
1825	invalidate();
1826	revalidate();
1827	repaint();
1828	}	1719	}
1829		1720
1830	private class ExplorerScrollPaneLayout extends ScrollPaneLayout {	1721	private class ExplorerScrollPaneLayout extends ScrollPaneLayout {
Lines 1832-1851 Link Here
1832	@Override	1723	@Override
1833	public void layoutContainer( Container parent ) {	1724	public void layoutContainer( Container parent ) {
1834	super.layoutContainer(parent);	1725	super.layoutContainer(parent);
1835	if( null != searchpanel && searchpanel.isVisible() ) {	1726	if( null != searchPanel && searchPanel.isVisible() ) {
1836	Insets innerInsets = getInnerInsets();	1727	Insets innerInsets = getInnerInsets();
1837	Dimension prefSize = searchpanel.getPreferredSize();	1728	Dimension prefSize = searchPanel.getPreferredSize();
1838	searchpanel.setBounds(innerInsets.left, parent.getHeight()-innerInsets.bottom-prefSize.height,	1729	searchPanel.setBounds(innerInsets.left, parent.getHeight()-innerInsets.bottom-prefSize.height,
1839	parent.getWidth()-innerInsets.left-innerInsets.right, prefSize.height);	1730	parent.getWidth()-innerInsets.left-innerInsets.right, prefSize.height);
1840	}	1731	}
1841	}	1732	}
1842	}	1733	}
1843		1734
1844	private final class ExplorerTree extends JTree implements Autoscroll {	1735	private final class ExplorerTree extends JTree implements Autoscroll, QuickSearchListener {
1845	AutoscrollSupport support;	1736	AutoscrollSupport support;
1846	private String maxPrefix;	1737	private String maxPrefix;
1847	int SEARCH_FIELD_SPACE = 3;	1738	int SEARCH_FIELD_SPACE = 3;
1848	private boolean firstPaint = true;	1739	private boolean firstPaint = true;
		1740	/** The last search searchResults */
		1741	private List<TreePath> searchResults = new ArrayList<TreePath>();
		1742	/** The last selected index from the search searchResults. */
		1743	private int currentSelectionIndex;
		1744	private String lastSearchText;
1849		1745
1850		1746
1851	ExplorerTree(TreeModel model) {	1747	ExplorerTree(TreeModel model) {
Lines 2008-2013 Link Here
2008	new GuardedActions(3, fe);	1904	new GuardedActions(3, fe);
2009	}	1905	}
2010		1906
		1907	@Override
		1908	protected void processKeyEvent(KeyEvent e) {
		1909	qs.processKeyEvent(e);
		1910	if (!e.isConsumed()) {
		1911	super.processKeyEvent(e);
		1912	}
		1913	}
		1914
2011	private void repaintSelection() {	1915	private void repaintSelection() {
2012	int first = getSelectionModel().getMinSelectionRow();	1916	int first = getSelectionModel().getMinSelectionRow();
2013	int last = getSelectionModel().getMaxSelectionRow();	1917	int last = getSelectionModel().getMaxSelectionRow();
Lines 2039-2096 Link Here
2039		1943
2040	private void setupSearch() {	1944	private void setupSearch() {
2041	// Remove the default key listeners	1945	// Remove the default key listeners
2042	KeyListener[] keyListeners = getListeners(KeyListener.class);	1946	// KeyListener[] keyListeners = getListeners(KeyListener.class);
2043		1947	//
2044	for (int i = 0; i < keyListeners.length; i++) {	1948	// for (int i = 0; i < keyListeners.length; i++) {
2045	removeKeyListener(keyListeners[i]);	1949	// removeKeyListener(keyListeners[i]);
2046	}	1950	// }
2047		1951
2048	// create new key listeners	1952	qs = QuickSearch.attach(TreeView.this, searchConstraints);
2049	quickSearchKeyAdapter = (	1953	qs.addQuickSearchListener(this);
2050	new KeyAdapter() {
2051	@Override
2052	public void keyTyped(KeyEvent e) {
2053	int modifiers = e.getModifiers();
2054	int keyCode = e.getKeyCode();
2055	char c = e.getKeyChar();
2056
2057	//#43617 - don't eat + and -
2058	//#98634 - and all its duplicates dont't react to space
2059	if ((c == '+') \|\| (c == '-') \|\| (c==' ')) return; // NOI18N
2060
2061	if (((modifiers > 0) && (modifiers != KeyEvent.SHIFT_MASK)) \|\| e.isActionKey()) {
2062	return;
2063	}
2064
2065	if (Character.isISOControl(c) \|\|
2066	(keyCode == KeyEvent.VK_SHIFT) \|\|
2067	(keyCode == KeyEvent.VK_ESCAPE)) return;
2068
2069	final KeyStroke stroke = KeyStroke.getKeyStrokeForEvent(e);
2070	origSelectionPaths = getSelectionPaths();
2071	if (origSelectionPaths != null && origSelectionPaths.length == 0) {
2072	origSelectionPaths = null;
2073	}
2074	searchTextField.setText(String.valueOf(stroke.getKeyChar()));
2075
2076	displaySearchField();
2077	e.consume();
2078	}
2079	}
2080	);
2081	if(isQuickSearchAllowed()){
2082	addKeyListener(quickSearchKeyAdapter);
2083	}
2084	// Create a the "multi-event" listener for the text field. Instead of
2085	// adding separate instances of each needed listener, we're using a
2086	// class which implements them all. This approach is used in order
2087	// to avoid the creation of 4 instances which takes some time
2088	SearchFieldListener searchFieldListener = new SearchFieldListener();
2089	searchTextField.addKeyListener(searchFieldListener);
2090	searchTextField.addFocusListener(searchFieldListener);
2091	searchTextField.getDocument().addDocumentListener(searchFieldListener);
2092	}	1954	}
2093		1955
		1956	@Override
		1957	public void quickSearchUpdate(String searchText) {
		1958	lastSearchText = searchText;
		1959	currentSelectionIndex = 0;
		1960	searchResults.clear();
		1961	maxPrefix = null;
		1962
		1963	String text = searchText.toUpperCase();
		1964
		1965	if (text.length() > 0) {
		1966	searchResults = doSearch(text);
		1967	}
		1968	displaySearchResult();
		1969	}
		1970
		1971	@Override
		1972	public void showNextSelection(boolean forward) {
		1973	if (forward) {
		1974	currentSelectionIndex++;
		1975	} else {
		1976	currentSelectionIndex--;
		1977	}
		1978	displaySearchResult();
		1979	}
		1980
		1981	@Override
		1982	public String findMaxPrefix(String prefix) {
		1983	return maxPrefix;
		1984	}
		1985
		1986	@Override
		1987	public void quickSearchConfirmed() {
		1988	TreePath selectedTPath = getSelectionPath();
		1989	if (selectedTPath != null) {
		1990	TreeNode selectedTNode = (TreeNode) selectedTPath.getLastPathComponent();
		1991	Node selectedNode = Visualizer.findNode(selectedTNode);
		1992	performPreferredActionOnNodes(new Node[] { selectedNode });
		1993	}
		1994	origSelectionPaths = null;
		1995	searchResults.clear();
		1996	lastSearchText = null;
		1997	}
		1998
		1999	@Override
		2000	public void quickSearchCanceled() {
		2001	origSelectionPaths = null;
		2002	searchResults.clear();
		2003	lastSearchText = null;
		2004	}
		2005
2094	private List<TreePath> doSearch(String prefix) {	2006	private List<TreePath> doSearch(String prefix) {
2095	List<TreePath> results = new ArrayList<TreePath>();	2007	List<TreePath> results = new ArrayList<TreePath>();
2096	Set<TreePath> resSet = new HashSet<TreePath>();	2008	Set<TreePath> resSet = new HashSet<TreePath>();
Lines 2109-2115 Link Here
2109	while (true) {	2021	while (true) {
2110	startIndex = startIndex % size;	2022	startIndex = startIndex % size;
2111		2023
2112	SubstringSearchResult substringSearchResult = getNextSubstringMatch(prefix, startIndex, Position.Bias.Forward);	2024	SubstringSearchResult substringSearchResult = getNextSubstringMatch(prefix, startIndex, true);
2113	TreePath path = substringSearchResult != null? substringSearchResult.treePath: null;	2025	TreePath path = substringSearchResult != null? substringSearchResult.treePath: null;
2114		2026
2115	if ((path != null) && !resSet.contains(path)) {	2027	if ((path != null) && !resSet.contains(path)) {
Lines 2134-2140 Link Here
2134	maxPrefix = elementName;	2046	maxPrefix = elementName;
2135	}	2047	}
2136		2048
2137	maxPrefix = findMaxPrefix(maxPrefix, elementName);	2049	maxPrefix = QuickSearch.findMaxPrefix(maxPrefix, elementName, true);
2138	}	2050	}
2139	// try next element	2051	// try next element
2140	startIndex++;	2052	startIndex++;
Lines 2146-2161 Link Here
2146	return results;	2058	return results;
2147	}	2059	}
2148		2060
2149	private String findMaxPrefix(String str1, String str2) {
2150	String res = null;
2151
2152	for (int i = 0; str1.regionMatches(true, 0, str2, 0, i); i++) {
2153	res = str1.substring(0, i);
2154	}
2155
2156	return res;
2157	}
2158
2159	/**	2061	/**
2160	* Copied and adapted from JTree.getNextMatch(...).	2062	* Copied and adapted from JTree.getNextMatch(...).
2161	*	2063	*
Lines 2163-2169 Link Here
2163	* and the index of the first occurrence of the substring in TreePath.	2065	* and the index of the first occurrence of the substring in TreePath.
2164	*/	2066	*/
2165	private SubstringSearchResult getNextSubstringMatch(	2067	private SubstringSearchResult getNextSubstringMatch(
2166	String substring, int startingRow, Position.Bias bias) {	2068	String substring, int startingRow, boolean forward) {
2167		2069
2168	int max = getRowCount();	2070	int max = getRowCount();
2169	if (substring == null) {	2071	if (substring == null) {
Lines 2176-2182 Link Here
2176		2078
2177	// start search from the next/previous element froom the	2079	// start search from the next/previous element froom the
2178	// selected element	2080	// selected element
2179	int increment = (bias == Position.Bias.Forward) ? 1 : -1;	2081	int increment = (forward) ? 1 : -1;
2180	int row = startingRow;	2082	int row = startingRow;
2181	do {	2083	do {
2182	TreePath path = getPathForRow(row);	2084	TreePath path = getPathForRow(row);
Lines 2193-2198 Link Here
2193	return null;	2095	return null;
2194	}	2096	}
2195		2097
		2098	private void displaySearchResult() {
		2099	int sz = searchResults.size();
		2100
		2101	if (sz > 0) {
		2102	if (currentSelectionIndex < 0) {
		2103	currentSelectionIndex = sz - 1;
		2104	} else if (currentSelectionIndex >= sz) {
		2105	currentSelectionIndex = 0;
		2106	}
		2107
		2108	TreePath path = searchResults.get(currentSelectionIndex);
		2109	setSelectionPath(path);
		2110	scrollPathToVisible(path);
		2111	} else {
		2112	if (lastSearchText.isEmpty() && origSelectionPaths != null) {
		2113	setSelectionPaths(origSelectionPaths);
		2114	scrollPathToVisible(origSelectionPaths[0]);
		2115	} else {
		2116	clearSelection();
		2117	}
		2118	}
		2119	}
		2120
2196	/** notify the Component to autoscroll */	2121	/** notify the Component to autoscroll */
2197	@Override	2122	@Override
2198	public void autoscroll(Point cursorLoc) {	2123	public void autoscroll(Point cursorLoc) {
Lines 2295-2425 Link Here
2295	}	2220	}
2296	}	2221	}
2297		2222
2298	private class SearchFieldListener extends KeyAdapter implements DocumentListener, FocusListener {
2299	/** The last search results */
2300	private List<TreePath> results = new ArrayList<TreePath>();
2301
2302	/** The last selected index from the search results. */
2303	private int currentSelectionIndex;
2304
2305	SearchFieldListener() {
2306	}
2307
2308	@Override
2309	public void changedUpdate(DocumentEvent e) {
2310	searchForNode();
2311	}
2312
2313	@Override
2314	public void insertUpdate(DocumentEvent e) {
2315	searchForNode();
2316	}
2317
2318	@Override
2319	public void removeUpdate(DocumentEvent e) {
2320	searchForNode();
2321	}
2322
2323	@Override
2324	public void keyPressed(KeyEvent e) {
2325	int keyCode = e.getKeyCode();
2326
2327	if (keyCode == KeyEvent.VK_ESCAPE) {
2328	removeSearchField();
2329	ExplorerTree.this.requestFocus();
2330	} else if (keyCode == KeyEvent.VK_UP \|\| (keyCode == KeyEvent.VK_F3 && e.isShiftDown())) {
2331	currentSelectionIndex--;
2332	displaySearchResult();
2333
2334	// Stop processing the event here. Otherwise it's dispatched
2335	// to the tree too (which scrolls)
2336	e.consume();
2337	} else if (keyCode == KeyEvent.VK_DOWN \|\| keyCode == KeyEvent.VK_F3) {
2338	currentSelectionIndex++;
2339	displaySearchResult();
2340
2341	// Stop processing the event here. Otherwise it's dispatched
2342	// to the tree too (which scrolls)
2343	e.consume();
2344	} else if (keyCode == KeyEvent.VK_TAB) {
2345	if (maxPrefix != null) {
2346	searchTextField.setText(maxPrefix);
2347	}
2348
2349	e.consume();
2350	} else if (keyCode == KeyEvent.VK_ENTER) {
2351	removeSearchField();
2352
2353	// bugfix #39607, don't expand selected node when default action invoked
2354	TreePath selectedTPath = getSelectionPath();
2355
2356	if (selectedTPath != null) {
2357	TreeNode selectedTNode = (TreeNode) selectedTPath.getLastPathComponent();
2358	Node selectedNode = Visualizer.findNode(selectedTNode);
2359
2360	if (
2361	(selectedNode.getPreferredAction() == null) \|\|
2362	!selectedNode.getPreferredAction().isEnabled()
2363	) {
2364	expandPath(getSelectionPath());
2365	}
2366	}
2367
2368	ExplorerTree.this.requestFocus();
2369	ExplorerTree.this.dispatchEvent(e);
2370	}
2371	}
2372
2373	/** Searches for a node in the tree. */
2374	private void searchForNode() {
2375	currentSelectionIndex = 0;
2376	results.clear();
2377	maxPrefix = null;
2378
2379	String text = searchTextField.getText().toUpperCase();
2380
2381	if (text.length() > 0) {
2382	results = doSearch(text);
2383	}
2384	displaySearchResult();
2385	}
2386
2387	private void displaySearchResult() {
2388	int sz = results.size();
2389
2390	if (sz > 0) {
2391	if (currentSelectionIndex < 0) {
2392	currentSelectionIndex = sz - 1;
2393	} else if (currentSelectionIndex >= sz) {
2394	currentSelectionIndex = 0;
2395	}
2396
2397	TreePath path = results.get(currentSelectionIndex);
2398	setSelectionPath(path);
2399	scrollPathToVisible(path);
2400	} else {
2401	if (searchTextField.getText().length() == 0 && origSelectionPaths != null) {
2402	setSelectionPaths(origSelectionPaths);
2403	scrollPathToVisible(origSelectionPaths[0]);
2404	} else {
2405	clearSelection();
2406	}
2407	}
2408	}
2409
2410	@Override
2411	public void focusGained(FocusEvent e) {
2412	// make sure nothing is selected
2413	searchTextField.select(1, 1);
2414	}
2415
2416	@Override
2417	public void focusLost(FocusEvent e) {
2418	results.clear();
2419	removeSearchField();
2420	}
2421	}
2422
2423	private class AccessibleExplorerTree extends JTree.AccessibleJTree {	2223	private class AccessibleExplorerTree extends JTree.AccessibleJTree {
2424	AccessibleExplorerTree() {	2224	AccessibleExplorerTree() {
2425	}	2225	}

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 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>

Lines 132-137 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/OutlineView.java (-15 / +6 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 681-704 Link Here
681	}	682	}
682		683
683	/**	684	/**
684	* Test whether the quick search feature is enabled or not.	685	* Get the quick search support, that is attached to this view.
685	* Default is enabled (true).	686	* @return The quick search support.
686	* @since	687	* @since 6.43
687	* @return <code>true</code> if quick search feature is enabled, <code>false</code> otherwise.
688	*/	688	*/
689	/public/ boolean isQuickSearchAllowed() {	689	public final QuickSearch getQuickSearch() {
690	return quickSearch.isEnabled();	690	return quickSearch;
691	}	691	}
692		692
693	/**
694	* Set whether the quick search feature is enabled or not.
695	* @since
696	* @param allowedQuickSearch <code>true</code> if quick search shall be enabled
697	*/
698	/public/ void setQuickSearchAllowed(boolean allowedQuickSearch) {
699	quickSearch.setEnabled(allowedQuickSearch);
700	}
701
702	/** Initializes the component and lookup explorer manager.	693	/** Initializes the component and lookup explorer manager.
703	*/	694	*/
704	@Override	695	@Override

Lines 1-514 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/QuickSearch.java (-514 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	import java.awt.*;
45	import java.awt.event.*;
46	import java.lang.ref.WeakReference;
47	import java.util.LinkedList;
48	import java.util.List;
49	import javax.swing.*;
50	import javax.swing.event.DocumentEvent;
51	import javax.swing.event.DocumentListener;
52	import javax.swing.text.Position.Bias;
53
54	/**
55	* Quick search infrastructure
56	*
57	* @author Martin Entlicher
58	*/
59	class QuickSearch {
60
61	private static final String ICON_FIND = "org/openide/explorer/view/find.png";
62	private static final String ICON_FIND_WITH_MENU = "org/openide/explorer/view/findMenu.png";
63
64	private final JComponent component;
65	private final Object constraints;
66	private boolean enabled = true;
67	private final List<QuickSearchListener> listeners = new LinkedList<QuickSearchListener>();
68	private SearchTextField searchTextField;
69	private KeyAdapter quickSearchKeyAdapter;
70	private JPanel searchPanel;
71	private JMenu popupMenu;
72
73	private QuickSearch(JComponent component, Object constraints) {
74	this.component = component;
75	this.constraints = constraints;
76	setUpSearch();
77	}
78
79	public static QuickSearch attach(JComponent component, Object constraints) {
80	Object qso = component.getClientProperty(QuickSearch.class.getName());
81	if (qso instanceof QuickSearch) {
82	return (QuickSearch) qso;
83	} else {
84	QuickSearch qs = new QuickSearch(component, constraints);
85	component.putClientProperty(QuickSearch.class.getName(), qs);
86	return qs;
87	}
88	}
89
90	public void detach() {
91	setEnabled(false);
92	component.putClientProperty(QuickSearch.class.getName(), null);
93	}
94
95	public boolean isEnabled() {
96	return enabled;
97	}
98
99	public void setEnabled(boolean enabled) {
100	if (this.enabled == enabled) {
101	return ;
102	}
103	this.enabled = enabled;
104	if (enabled) {
105	component.addKeyListener(quickSearchKeyAdapter);
106	} else {
107	component.removeKeyListener(quickSearchKeyAdapter);
108	}
109	}
110
111	public void addQuickSearchListener(QuickSearchListener qsl) {
112	synchronized (listeners) {
113	listeners.add(qsl);
114	}
115	}
116
117	public void removeQuickSearchListener(QuickSearchListener qsl) {
118	synchronized (listeners) {
119	listeners.remove(qsl);
120	}
121	}
122
123	public void setPopupMenu(JMenu popupMenu) {
124	this.popupMenu = popupMenu;
125	}
126
127	public void processKeyEvent(KeyEvent ke) {
128	switch(ke.getID()) {
129	case KeyEvent.KEY_PRESSED:
130	quickSearchKeyAdapter.keyPressed(ke);
131	break;
132	case KeyEvent.KEY_RELEASED:
133	quickSearchKeyAdapter.keyReleased(ke);
134	break;
135	case KeyEvent.KEY_TYPED:
136	quickSearchKeyAdapter.keyTyped(ke);
137	break;
138	}
139	}
140
141	private QuickSearchListener[] getQuickSearchListeners() {
142	QuickSearchListener[] qsls;
143	synchronized (listeners) {
144	qsls = listeners.toArray(new QuickSearchListener[] {});
145	}
146	return qsls;
147	}
148
149	private void fireQuickSearchUpdate(String searchText) {
150	for (QuickSearchListener qsl : getQuickSearchListeners()) {
151	qsl.quickSearchUpdate(searchText);
152	}
153	}
154
155	private void fireShowNextSelection(Bias bias) {
156	for (QuickSearchListener qsl : getQuickSearchListeners()) {
157	qsl.showNextSelection(bias);
158	}
159	}
160
161	private String findMaxPrefix(String prefix) {
162	for (QuickSearchListener qsl : getQuickSearchListeners()) {
163	prefix = qsl.findMaxPrefix(prefix);
164	}
165	return prefix;
166	}
167
168	private void fireQuickSearchConfirmed() {
169	for (QuickSearchListener qsl : getQuickSearchListeners()) {
170	qsl.quickSearchConfirmed();
171	}
172	}
173
174	private void fireQuickSearchCanceled() {
175	for (QuickSearchListener qsl : getQuickSearchListeners()) {
176	qsl.quickSearchCanceled();
177	}
178	}
179
180	private void setUpSearch() {
181	searchTextField = new SearchTextField();
182	// create new key listeners
183	quickSearchKeyAdapter = (
184	new KeyAdapter() {
185	@Override
186	public void keyTyped(KeyEvent e) {
187	int modifiers = e.getModifiers();
188	int keyCode = e.getKeyCode();
189	char c = e.getKeyChar();
190
191	//#43617 - don't eat + and -
192	//#98634 - and all its duplicates dont't react to space
193	if ((c == '+') \|\| (c == '-') \|\| (c==' ')) return; // NOI18N
194
195	if (((modifiers > 0) && (modifiers != KeyEvent.SHIFT_MASK)) \|\| e.isActionKey()) {
196	return;
197	}
198
199	if (Character.isISOControl(c) \|\|
200	(keyCode == KeyEvent.VK_SHIFT) \|\|
201	(keyCode == KeyEvent.VK_ESCAPE)) return;
202
203	final KeyStroke stroke = KeyStroke.getKeyStrokeForEvent(e);
204	searchTextField.setText(String.valueOf(stroke.getKeyChar()));
205
206	displaySearchField();
207	e.consume();
208	}
209	}
210	);
211	if(isEnabled()){
212	component.addKeyListener(quickSearchKeyAdapter);
213	}
214	// Create a the "multi-event" listener for the text field. Instead of
215	// adding separate instances of each needed listener, we're using a
216	// class which implements them all. This approach is used in order
217	// to avoid the creation of 4 instances which takes some time
218	SearchFieldListener searchFieldListener = new SearchFieldListener();
219	searchTextField.addKeyListener(searchFieldListener);
220	searchTextField.addFocusListener(searchFieldListener);
221	searchTextField.getDocument().addDocumentListener(searchFieldListener);
222
223	}
224
225	private void displaySearchField() {
226	if (searchPanel != null \|\| !isEnabled()) {
227	return;
228	}
229	/*
230	TreeView previousSearchField = lastSearchField.get();
231	if (previousSearchField != null && previousSearchField != this) {
232	previousSearchField.removeSearchField();
233	}
234	*/
235	//JViewport vp = getViewport();
236	//originalScrollMode = vp.getScrollMode();
237	//vp.setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
238	searchTextField.setOriginalFocusOwner();
239	searchTextField.setFont(component.getFont());
240	searchPanel = new SearchPanel();
241	//JLabel lbl = new JLabel(NbBundle.getMessage(TreeView.class, "LBL_QUICKSEARCH")); //NOI18N
242	final JLabel lbl;
243	if (popupMenu != null) {
244	lbl = new JLabel(org.openide.util.ImageUtilities.loadImageIcon(ICON_FIND_WITH_MENU, false));
245	lbl.addMouseListener(new MouseAdapter() {
246	@Override
247	public void mousePressed(MouseEvent e) {
248	if (e != null && !SwingUtilities.isLeftMouseButton(e)) {
249	return;
250	}
251	JPopupMenu pm = popupMenu.getPopupMenu();
252	pm.show(lbl, 0, lbl.getHeight() - 1);
253	}
254	});
255	} else {
256	lbl = new JLabel(org.openide.util.ImageUtilities.loadImageIcon(ICON_FIND, false));
257	}
258	searchPanel.setLayout(new BoxLayout(searchPanel, BoxLayout.X_AXIS));
259	searchPanel.add(lbl);
260	searchPanel.add(searchTextField);
261	lbl.setLabelFor(searchTextField);
262	searchTextField.setColumns(10);
263	searchTextField.setMaximumSize(searchTextField.getPreferredSize());
264	searchTextField.putClientProperty("JTextField.variant", "search"); //NOI18N
265	lbl.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 5));
266	//JToggleButton matchCaseButton = new JToggleButton("aA");
267	//matchCaseButton.setBorder(BorderFactory.createEmptyBorder(0, 5, 0, 5));
268	//searchPanel.add(matchCaseButton);
269	if (component instanceof JScrollPane) {
270	// ((JScrollPane) component).getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
271	}
272	if (constraints == null) {
273	component.add(searchPanel);
274	} else {
275	component.add(searchPanel, constraints);
276	}
277	component.invalidate();
278	component.revalidate();
279	component.repaint();
280	searchTextField.requestFocus();
281	}
282
283	private void removeSearchField() {
284	if (searchPanel == null) {
285	return;
286	}
287	component.remove(searchPanel);
288	searchPanel = null;
289	//getViewport().setScrollMode(originalScrollMode);
290	component.invalidate();
291	component.revalidate();
292	component.repaint();
293	}
294
295	public static String findMaxCommonSubstring(String str1, String str2, boolean ignoreCase) {
296	int n1 = str1.length();
297	int n2 = str2.length();
298	int i = 0;
299	if (ignoreCase) {
300	for ( ; i < n1 && i < n2; i++) {
301	char c1 = Character.toUpperCase(str1.charAt(i));
302	char c2 = Character.toUpperCase(str2.charAt(i));
303	if (c1 != c2) {
304	break;
305	}
306	}
307	} else {
308	for ( ; i < n1 && i < n2; i++) {
309	char c1 = str1.charAt(i);
310	char c2 = str2.charAt(i);
311	if (c1 != c2) {
312	break;
313	}
314	}
315	}
316	return str1.substring(0, i);
317	}
318
319	public static interface QuickSearchListener {
320
321	void quickSearchUpdate(String searchText);
322
323	void showNextSelection(Bias bias);
324
325	String findMaxPrefix(String prefix);
326
327	void quickSearchConfirmed();
328
329	void quickSearchCanceled();
330
331	}
332
333	private static class SearchPanel extends JPanel {
334
335	public SearchPanel() {
336	if (ViewUtil.isAquaLaF) {
337	setBorder(BorderFactory.createEmptyBorder(9,6,8,2));
338	} else {
339	setBorder(BorderFactory.createEmptyBorder(2,6,2,2));
340	}
341	setOpaque(true);
342	}
343
344	@Override
345	protected void paintComponent(Graphics g) {
346	if (ViewUtil.isAquaLaF && g instanceof Graphics2D) {
347	Graphics2D g2d = (Graphics2D) g;
348	g2d.setPaint(new GradientPaint(0, 0, UIManager.getColor("NbExplorerView.quicksearch.background.top"),
349	0, getHeight(), UIManager.getColor("NbExplorerView.quicksearch.background.bottom")));//NOI18N
350	g2d.fillRect(0, 0, getWidth(), getHeight());
351	g2d.setColor(UIManager.getColor("NbExplorerView.quicksearch.border")); //NOI18N
352	g2d.drawLine(0, 0, getWidth(), 0);
353	} else {
354	super.paintComponent(g);
355	}
356	}
357	}
358
359	/** searchTextField manages focus because it handles VK_ESCAPE key */
360	private class SearchTextField extends JTextField {
361
362	private WeakReference<Component> originalFocusOwner = new WeakReference<Component>(null);
363
364	public SearchTextField() {
365	}
366
367	void setOriginalFocusOwner() {
368	Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
369	if (focusOwner != null && component.isAncestorOf(focusOwner)) {
370	originalFocusOwner = new WeakReference<Component>(focusOwner);
371	} else {
372	originalFocusOwner = new WeakReference<Component>(component);
373	}
374	}
375
376	void requestOriginalFocusOwner() {
377	SwingUtilities.invokeLater(
378	new Runnable() {
379	//additional bugfix - do focus change later or removing
380	//the component while it's focused will cause focus to
381	//get transferred to the next component in the
382	//parent focusTraversalPolicy after our request
383	//focus completes, so focus goes into a black hole - Tim
384	@Override
385	public void run() {
386	Component fo = originalFocusOwner.get();
387	if (fo != null) {
388	fo.requestFocusInWindow();
389	}
390	}
391	}
392	);
393	}
394
395	@Override
396	public boolean isManagingFocus() {
397	return true;
398	}
399
400	@Override
401	public void processKeyEvent(KeyEvent ke) {
402	//override the default handling so that
403	//the parent will never receive the escape key and
404	//close a modal dialog
405	if (ke.getKeyCode() == KeyEvent.VK_ESCAPE) {
406	removeSearchField();
407	ke.consume();
408	// bugfix #32909, reqest focus when search field is removed
409	requestOriginalFocusOwner();
410	fireQuickSearchCanceled();
411	} else {
412	super.processKeyEvent(ke);
413	}
414	}
415	};
416
417	private class SearchFieldListener extends KeyAdapter implements DocumentListener, FocusListener {
418
419	private boolean ignoreEvents;
420
421	SearchFieldListener() {
422	}
423
424	@Override
425	public void changedUpdate(DocumentEvent e) {
426	if (ignoreEvents) return;
427	searchForNode();
428	}
429
430	@Override
431	public void insertUpdate(DocumentEvent e) {
432	if (ignoreEvents) return;
433	searchForNode();
434	}
435
436	@Override
437	public void removeUpdate(DocumentEvent e) {
438	if (ignoreEvents) return;
439	searchForNode();
440	}
441
442	@Override
443	public void keyPressed(KeyEvent e) {
444	int keyCode = e.getKeyCode();
445
446	if (keyCode == KeyEvent.VK_ESCAPE) {
447	removeSearchField();
448	searchTextField.requestOriginalFocusOwner();
449	fireQuickSearchCanceled();
450	e.consume();
451	} else if (keyCode == KeyEvent.VK_UP \|\| (keyCode == KeyEvent.VK_F3 && e.isShiftDown())) {
452	fireShowNextSelection(Bias.Backward);
453	// Stop processing the event here. Otherwise it's dispatched
454	// to the tree too (which scrolls)
455	e.consume();
456	} else if (keyCode == KeyEvent.VK_DOWN \|\| keyCode == KeyEvent.VK_F3) {
457	fireShowNextSelection(Bias.Forward);
458	// Stop processing the event here. Otherwise it's dispatched
459	// to the tree too (which scrolls)
460	e.consume();
461	} else if (keyCode == KeyEvent.VK_TAB) {
462	String maxPrefix = findMaxPrefix(searchTextField.getText());
463	ignoreEvents = true;
464	try {
465	searchTextField.setText(maxPrefix);
466	} finally {
467	ignoreEvents = false;
468	}
469
470	e.consume();
471	} else if (keyCode == KeyEvent.VK_ENTER) {
472	removeSearchField();
473	fireQuickSearchConfirmed();
474
475	component.requestFocusInWindow();
476	e.consume();
477	}
478	}
479
480	/** Searches for a node in the tree. */
481	private void searchForNode() {
482	String text = searchTextField.getText();
483	fireQuickSearchUpdate(text);
484	}
485
486	@Override
487	public void focusGained(FocusEvent e) {
488	if (e.getSource() == searchTextField) {
489	// make sure nothing is selected
490	int n = searchTextField.getText().length();
491	searchTextField.select(n, n);
492	}
493	}
494
495	@Override
496	public void focusLost(FocusEvent e) {
497	if (e.isTemporary()) return ;
498	Component oppositeComponent = e.getOppositeComponent();
499	if (e.getSource() != searchTextField) {
500	((Component) e.getSource()).removeFocusListener(this);
501	}
502	if (oppositeComponent instanceof JMenuItem \|\| oppositeComponent instanceof JPopupMenu) {
503	oppositeComponent.addFocusListener(this);
504	return ;
505	}
506	if (oppositeComponent == searchTextField) {
507	return ;
508	}
509	removeSearchField();
510	fireQuickSearchConfirmed();
511	}
512	}
513
514	}

Lines 61-67 Link Here

(-)a/openide.explorer/src/org/openide/explorer/view/TableQuickSearchSupport.java (-14 / +15 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.awt.QuickSearchListener;
65	import org.openide.util.NbBundle;	66	import org.openide.util.NbBundle;
66	import org.openide.util.NbPreferences;	67	import org.openide.util.NbPreferences;
67		68
Lines 70-76 Link Here
70	*	71	*
71	* @author Martin Entlicher	72	* @author Martin Entlicher
72	*/	73	*/
73	class TableQuickSearchSupport implements QuickSearch.QuickSearchListener {	74	class TableQuickSearchSupport implements QuickSearchListener {
74		75
75	private int quickSearchInitialRow = -1; // The search was initiated here	76	private int quickSearchInitialRow = -1; // The search was initiated here
76	private int quickSearchInitialColumn = -1; // The search was initiated here	77	private int quickSearchInitialColumn = -1; // The search was initiated here
Lines 103-114 Link Here
103	}	104	}
104	quickSearchLastRow = quickSearchInitialRow;	105	quickSearchLastRow = quickSearchInitialRow;
105	quickSearchLastColumn = quickSearchInitialColumn;	106	quickSearchLastColumn = quickSearchInitialColumn;
106	doSearch(searchText, Position.Bias.Forward);	107	doSearch(searchText, true);
107	}	108	}
108		109
109	@Override	110	@Override
110	public void showNextSelection(Position.Bias bias) {	111	public void showNextSelection(boolean forward) {
111	if (bias == Position.Bias.Forward) {	112	if (forward) {
112	if (++quickSearchLastColumn >= table.getColumnCount()) {	113	if (++quickSearchLastColumn >= table.getColumnCount()) {
113	quickSearchLastColumn = 0;	114	quickSearchLastColumn = 0;
114	if (++quickSearchLastRow >= table.getRowCount()) {	115	if (++quickSearchLastRow >= table.getRowCount()) {
Lines 116-122 Link Here
116	}	117	}
117	}	118	}
118	}	119	}
119	doSearch(lastSearchText, bias);	120	doSearch(lastSearchText, forward);
120	}	121	}
121		122
122	@Override	123	@Override
Lines 145-151 Link Here
145	if (maxPrefix == null) {	146	if (maxPrefix == null) {
146	maxPrefix = str;	147	maxPrefix = str;
147	} else {	148	} else {
148	maxPrefix = QuickSearch.findMaxCommonSubstring(maxPrefix, str, !qss.isMatchCase());	149	maxPrefix = QuickSearch.findMaxPrefix(maxPrefix, str, !qss.isMatchCase());
149	}	150	}
150	}	151	}
151	}	152	}
Lines 170-190 Link Here
170	quickSearchInitialColumn = -1;	171	quickSearchInitialColumn = -1;
171	}	172	}
172		173
173	private void doSearch(String searchText, Position.Bias bias) {	174	private void doSearch(String searchText, boolean forward) {
174	if (!qss.isMatchCase()) {	175	if (!qss.isMatchCase()) {
175	searchText = searchText.toUpperCase();	176	searchText = searchText.toUpperCase();
176	}	177	}
177	int n = table.getRowCount();	178	int n = table.getRowCount();
178	boolean backward = bias == Position.Bias.Backward;	179	//boolean backward = bias == Position.Bias.Backward;
179	int row1 = quickSearchLastRow;	180	int row1 = quickSearchLastRow;
180	int row2 = quickSearchLastRow + n;	181	int row2 = quickSearchLastRow + n;
181	boolean lineStartSearch = true;	182	boolean lineStartSearch = true;
182	Set<String> columnsIgnoredToSearch = qss.getColumnsIgnoredToSearch();	183	Set<String> columnsIgnoredToSearch = qss.getColumnsIgnoredToSearch();
183	do {	184	do {
184	int col1 = quickSearchLastColumn;	185	int col1 = quickSearchLastColumn;
185	int col2 = (backward) ? 0 : table.getColumnCount();	186	int col2 = (forward) ? table.getColumnCount() : 0;
186	for (int row = (backward) ? (row2 - 1) : row1; (backward) ? row >= row1 : row < row2; row = (backward) ? --row : ++row) {	187	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) {	188	for (int col = col1; (forward) ? col < col2 : col >= col2; col = (forward) ? ++col : --col) {
188	String cName = table.getColumnName(col);	189	String cName = table.getColumnName(col);
189	if (columnsIgnoredToSearch.contains(cName)) {	190	if (columnsIgnoredToSearch.contains(cName)) {
190	continue;	191	continue;
Lines 208-214 Link Here
208	}	209	}
209	}	210	}
210	}	211	}
211	col1 = (backward) ? table.getColumnCount() - 1 : 0;	212	col1 = (forward) ? 0 : table.getColumnCount() - 1;
212	}	213	}
213	lineStartSearch = !lineStartSearch;	214	lineStartSearch = !lineStartSearch;
214	} while (!lineStartSearch);	215	} while (!lineStartSearch);
Lines 234-240 Link Here
234	return TableQuickSearchSupport.getSearchPopupMenu(qss, table.getColumnModel(), new ActionListener() {	235	return TableQuickSearchSupport.getSearchPopupMenu(qss, table.getColumnModel(), new ActionListener() {
235	@Override	236	@Override
236	public void actionPerformed(ActionEvent e) {	237	public void actionPerformed(ActionEvent e) {
237	doSearch(lastSearchText, Position.Bias.Forward);	238	doSearch(lastSearchText, true);
238	}	239	}
239	});	240	});
240	}	241	}