Attachment #127729 for bug #221993

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




    <!-- ACTUAL CHANGES BEGIN HERE: -->

    <changes>
        <change id="ReplaceHistory">
            <api name="api.search"/>
            <summary>Added ReplacePattern and replace history to SearchHistory class</summary>
            <version major="1" minor="1.8"/>
            <date day="20" month="11" year="2012"/>
            <author login="mkristofic"/>
            <compatibility addition="yes"/>
            <description>
                <p>
                    Search History has two new methods: addReplace() and getReplacePatterns().
                    It has one more property name ADD_TO_REPLACE for firing changes in replacepatternlist.
                    Replace implementation is identical to Search history with Search Patterns..
                </p>
                <p> 
                    New ReplacePattern has two variables - replaceExpression and preserveCase. It is a wrap class for replace expression.
                </p>
            </description>
            <class package="org.netbeans.api.search" name="ReplacePattern"/>
            <class package="org.netbeans.api.search" name="SearchHistory"/>
        </change>
        
        <change id="SearchResultsDisplayer-closed">
            <api name="api.search"/>
            <summary>Added method SearchResultsDisplayer.closed()</summary>

Lines 1-5 Link Here

(-)a/api.search/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.api.search	2	OpenIDE-Module: org.netbeans.api.search
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/api/search/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/api/search/Bundle.properties
4	OpenIDE-Module-Specification-Version: 1.7	4	OpenIDE-Module-Specification-Version: 1.8
5		5




package org.netbeans.api.search;

/**
 * Pattern describes the replace conditions
 * @since 1.8
 * @author Martin Roskanin
 */
public final class ReplacePattern {

    private String replaceExpression;
    private boolean preserveCase;
    
    private ReplacePattern(String replaceExpression, boolean preserveCase) {
        this.replaceExpression = replaceExpression;
        this.preserveCase = preserveCase;
     */
    private boolean wholeWords;
    /**
     * if true, case sensitive search was preformed
     */
    private boolean matchCase;
    /**
     * if true, regular expression search was performed
     */
    private boolean regExp;

    /**
     * Creates a new instance of SearchPattern
     *
     * @param searchExpression a searched text
     * @param wholeWords if true, only whole words were searched
     * @param matchCase if true, case sensitive search was preformed
     * @param regExp if true, regular expression search was performed
     */
    private SearchPattern(String searchExpression, boolean wholeWords,
            boolean matchCase, boolean regExp) {
        this.searchExpression = searchExpression;
        this.wholeWords = wholeWords;
        this.matchCase = matchCase;
        this.regExp = regExp;
    }

    /**
     * Creates a new ReplacePattern in accordance with given parameters
     *
     * @param searchExpression non-null String of a searched text
     * @param wholeWords if true, only whole words were searched
     * @param matchCase if true, case sensitive search was preformed
     * @param regExp if true, regular expression search was performed
     * @return a new SearchPattern in accordance with given parameters
     */
    public static ReplacePattern create(String replaceExpression, boolean preserveCase) {
        return new ReplacePattern(replaceExpression, preserveCase);
    }
    
    public String getReplaceExpression() {
        return replaceExpression;
    }

    public boolean isPreserveCase() {
        return preserveCase;
     */
    public String getSearchExpression() {
        return searchExpression;
    }
    
    /**
     * @return true if the wholeWords parameter was used during search
     * performing
     */
    public boolean isWholeWords() {
        return wholeWords;
    }

    /**
     * @return true if the matchCase parameter was used during search performing
     */
    public boolean isMatchCase() {
        return matchCase;
    }

    /**
     * @return true if the regExp parameter was used during search performing
     */
    public boolean isRegExp() {
        return regExp;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof ReplacePattern)) {
            return false;
        }
        ReplacePattern sp = (ReplacePattern) obj;
        return (this.replaceExpression.equals(sp.getReplaceExpression())
                && this.preserveCase == sp.isPreserveCase());
                && this.matchCase == sp.isMatchCase()
                && this.regExp == sp.isRegExp());
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 37 * result + (this.preserveCase ? 1 : 0);
        result = 37 * result + this.replaceExpression.hashCode();
        result = 37 * result + (this.regExp ? 1 : 0);
        result = 37 * result + this.searchExpression.hashCode();
        return result;
    }

    /**
     * Create new instance with "replace expression" set to passed value, and
     * other values copied from this instance.
     *
     */
    public ReplacePattern changeReplaceExpression(String expression) {
        if ((expression == null && this.replaceExpression == null)
                || (expression != null
                && expression.equals(this.replaceExpression))) {
            return this;
        } else {
            return ReplacePattern.create(expression, preserveCase);
                    matchCase, regExp);
        }
    }

    /**
     * Create new instance with "preserve case" set to passed value, and other
     * values copied from this instance.
     *
     */
    public ReplacePattern changePreserveCase(boolean preserveCase) {
        if (this.preserveCase == preserveCase) {
            return this;
        } else {
            return ReplacePattern.create(replaceExpression, preserveCase);
                    matchCase, regExp);
        }
    }

    /**
     * Create new instance with "match case" set to passed value, and other
     * values copied from this instance.
     *
     */
    public SearchPattern changeMatchCase(boolean matchCase) {
        if (this.matchCase == matchCase) {
            return this;
        } else {
            return SearchPattern.create(searchExpression, wholeWords,
                    matchCase, regExp);
        }
    }

    /**
     * Create new instance with "regular expression" set to passed value, and
     * other values copied from this instance.
     *
     */
    public SearchPattern changeRegExp(boolean regExp) {
        if (this.regExp == regExp) {
            return this;
        } else {
            return SearchPattern.create(searchExpression, wholeWords,
                    matchCase, regExp);
        }
    }
    
    String toCanonicalString() {
        char p = isPreserveCase()? 'P' : 'p';
        return "" + p + "-" + getReplaceExpression(); //NOI18N
        char w = isWholeWords() ? 'W' : 'w';
        return "" + m + r + w + "-" + getSearchExpression();
    }

    static ReplacePattern parsePattern(String canonicalString) {
        //format p-replaceWith
        if (canonicalString == null
                || Character.toUpperCase(canonicalString.charAt(0)) != 'P'
                || canonicalString.charAt(1) != '-') {
                || Character.toUpperCase(canonicalString.charAt(2)) != 'W'
                || canonicalString.charAt(3) != '-') {
            return null;
        }
        
        boolean preserveCase = Character.isUpperCase(canonicalString.charAt(0));
        String replaceWith = canonicalString.substring(2);
        return new ReplacePattern(replaceWith, preserveCase);
        return new SearchPattern(findWhat, wholeWords, matchCase, regExp);
    }

}

Lines 79-89 Link Here

(-)a/api.search/src/org/netbeans/api/search/SearchHistory.java (-4 / +61 lines)
79	private static final int MAX_SEARCH_PATTERNS_ITEMS = 10;	79	private static final int MAX_SEARCH_PATTERNS_ITEMS = 10;
80		80
81	/** Limit for stored pattern length */	81	/** Limit for stored pattern length */
82	private static final int MAX_PATTERN_LENGHT = 16384; // 16 kB	82	private static final int MAX_PATTERN_LENGTH = 16384; // 16 kB
83		83
84	/** Shareable SearchPattern history. It is a List of SearchPatterns */	84	/** Shareable SearchPattern history. It is a List of SearchPatterns */
85	private List<SearchPattern> searchPatternsList	85	private List<SearchPattern> searchPatternsList
86	= new ArrayList<SearchPattern>(MAX_SEARCH_PATTERNS_ITEMS);	86	= new ArrayList<SearchPattern>(MAX_SEARCH_PATTERNS_ITEMS);
		87
		88	private List<ReplacePattern> replacePatternsList = new ArrayList<ReplacePattern>(MAX_SEARCH_PATTERNS_ITEMS);
87		89
88	/** Singleton instance */	90	/** Singleton instance */
89	private static SearchHistory INSTANCE = null;	91	private static SearchHistory INSTANCE = null;
Lines 103-114 Link Here
103	* newValue - added pattern	105	* newValue - added pattern
104	*/	106	*/
105	public final static String ADD_TO_HISTORY = "add-to-history"; //NOI18N	107	public final static String ADD_TO_HISTORY = "add-to-history"; //NOI18N
		108
		109	/** Property name for adding replace pattern that was not in history
		110	* Firing:
		111	* oldValue - null
		112	* newValue - added pattern
		113	* @since 1.8
		114	*/
		115	public final static String ADD_TO_REPLACE = "add-to-replace"; //NOI18N
106		116
107	/** Preferences node for storing history info */	117	/** Preferences node for storing history info */
108	private static Preferences prefs;	118	private static Preferences prefs;
109	/** Name of preferences node where we persist history */	119	/** Name of preferences node where we persist history */
110	private static final String PREFS_NODE = "SearchHistory"; //NOI18N	120	private static final String PREFS_NODE = "SearchHistory"; //NOI18N
111	private static final String PROP_SEARCH_PATTERN_PREFIX = "search_"; //NOI18N	121	private static final String PROP_SEARCH_PATTERN_PREFIX = "search_"; //NOI18N
		122	private static final String PROP_REPLACE_PATTERN_PREFIX = "replace_"; //NOI18N
112		123
113	/** Creates a new instance of SearchHistory */	124	/** Creates a new instance of SearchHistory */
114	private SearchHistory() {	125	private SearchHistory() {
Lines 129-137 Link Here
129	*/	140	*/
130	private void load () {	141	private void load () {
131	for(int i=0; i < MAX_SEARCH_PATTERNS_ITEMS; i++){	142	for(int i=0; i < MAX_SEARCH_PATTERNS_ITEMS; i++){
132	SearchPattern pattern = SearchPattern.parseSearchPattern(prefs.get(PROP_SEARCH_PATTERN_PREFIX + i, null));	143	SearchPattern pattern = SearchPattern.parsePattern(prefs.get(PROP_SEARCH_PATTERN_PREFIX + i, null));
133	if (pattern != null)	144	if (pattern != null) {
134	searchPatternsList.add(pattern);	145	searchPatternsList.add(pattern);
		146	}
		147	}
		148
		149	for(int i=0; i < MAX_SEARCH_PATTERNS_ITEMS; i++){
		150	ReplacePattern pattern = ReplacePattern.parsePattern(prefs.get(PROP_REPLACE_PATTERN_PREFIX + i, null));
		151	if (pattern != null) {
		152	replacePatternsList.add(pattern);
		153	}
135	}	154	}
136	}	155	}
137		156
Lines 185-197 Link Here
185	return Collections.unmodifiableList(searchPatternsList);	204	return Collections.unmodifiableList(searchPatternsList);
186	}	205	}
187		206
		207	/** @return unmodifiable List of ReplacePatterns
		208	* @since 1.8
		209	*/
		210	public synchronized List<ReplacePattern> getReplacePatterns(){
		211	return Collections.unmodifiableList(replacePatternsList);
		212	}
		213
188	/** Adds SearchPattern to SearchHistory	214	/** Adds SearchPattern to SearchHistory
189	* @param pattern the SearchPattern to add	215	* @param pattern the SearchPattern to add
190	*/	216	*/
191	public synchronized void add(SearchPattern pattern) {	217	public synchronized void add(SearchPattern pattern) {
192	if (pattern == null \|\| pattern.getSearchExpression() == null \|\| pattern.getSearchExpression().length() == 0	218	if (pattern == null \|\| pattern.getSearchExpression() == null \|\| pattern.getSearchExpression().length() == 0
193	\|\| (searchPatternsList.size() > 0 && pattern.equals(searchPatternsList.get(0))	219	\|\| (searchPatternsList.size() > 0 && pattern.equals(searchPatternsList.get(0))
194	\|\| pattern.getSearchExpression().length() > MAX_PATTERN_LENGHT)) {	220	\|\| pattern.getSearchExpression().length() > MAX_PATTERN_LENGTH)) {
195	return;	221	return;
196	}	222	}
197		223
Lines 215-220 Link Here
215	}	241	}
216	}	242	}
217		243
		244	/** Adds ReplacePattern to ReplaceHistory
		245	* @param pattern the ReplacePattern to add
		246	* @since 1.8
		247	*/
		248	public synchronized void addReplace(ReplacePattern pattern) {
		249	if (pattern == null \|\| pattern.getReplaceExpression() == null \|\| pattern.getReplaceExpression().length() == 0
		250	\|\| (replacePatternsList.size() > 0 && pattern.equals(replacePatternsList.get(0))
		251	\|\| pattern.getReplaceExpression().length() > MAX_PATTERN_LENGTH)) {
		252	return;
		253	}
		254
		255	for (int i = 0; i < replacePatternsList.size(); i++) {
		256	if (pattern.getReplaceExpression().equals(replacePatternsList.get(i).getReplaceExpression())) {
		257	replacePatternsList.remove(i);
		258	break;
		259	}
		260	}
		261
		262	if (replacePatternsList.size() == MAX_SEARCH_PATTERNS_ITEMS){
		263	replacePatternsList.remove(MAX_SEARCH_PATTERNS_ITEMS-1);
		264	}
		265	replacePatternsList.add(0, pattern);
		266
		267	for(int i=0;i < replacePatternsList.size();i++){
		268	prefs.put(PROP_REPLACE_PATTERN_PREFIX + i, replacePatternsList.get(i).toCanonicalString());
		269	}
		270	if (pcs != null) {
		271	pcs.firePropertyChange(ADD_TO_REPLACE, null, pattern);
		272	}
		273	}
		274
218	/**	275	/**
219	* Store last used file name pattern.	276	* Store last used file name pattern.
220	*	277	*

Lines 210-219 Link Here

(-)a/api.search/src/org/netbeans/api/search/SearchPattern.java (-2 / +2 lines)
210	char m = isMatchCase() ? 'M' : 'm';	210	char m = isMatchCase() ? 'M' : 'm';
211	char r = isRegExp() ? 'R' : 'r';	211	char r = isRegExp() ? 'R' : 'r';
212	char w = isWholeWords() ? 'W' : 'w';	212	char w = isWholeWords() ? 'W' : 'w';
213	return "" + m + r + w + "-" + getSearchExpression();	213	return "" + m + r + w + "-" + getSearchExpression(); //NOI18N
214	}	214	}
215		215
216	static SearchPattern parseSearchPattern(String canonicalString) {	216	static SearchPattern parsePattern(String canonicalString) {
217	//format mrw-findwhat	217	//format mrw-findwhat
218	if (canonicalString == null	218	if (canonicalString == null
219	\|\| Character.toUpperCase(canonicalString.charAt(0)) != 'M'	219	\|\| Character.toUpperCase(canonicalString.charAt(0)) != 'M'




 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.api.search;

import org.junit.AfterClass;
import org.junit.Test;
import static org.junit.Assert.*;
import org.junit.BeforeClass;


public class ReplacePatternTest {
 * @author mito
 */
public class SearchPatternTest {
    
    @Test
    public void testManuallyParse() throws Exception {
        String canString= "P-Test";
        ReplacePattern rp = ReplacePattern.parsePattern(canString);
        assertTrue(rp.isPreserveCase());
        assertEquals("Test", rp.getReplaceExpression());
        
        canString= "p--Test2";
        rp = ReplacePattern.parsePattern(canString);
        assertFalse(rp.isPreserveCase());
        assertEquals("-Test2", rp.getReplaceExpression());
    }

    @Test
    public void testManuallyCanString() throws Exception {
        ReplacePattern rp = ReplacePattern.create("ta", true);
        String canString = rp.toCanonicalString();
        assertEquals("P-ta", canString);
        
        rp = ReplacePattern.create("pa", false);
        canString = rp.toCanonicalString();
        assertEquals("p-pa", canString);
    }
}

Lines 42-48 Link Here

(-)a/api.search/test/unit/src/org/netbeans/api/search/provider/impl/SearchHistoryTest.java (-1 / +1 lines)
42	* made subject to such option by the copyright holder.	42	* made subject to such option by the copyright holder.
43	*/	43	*/
44		44
45	package org.netbeans.api.search.provider.impl;	45	package org.netbeans.api.search;
46		46
47	import java.beans.PropertyChangeEvent;	47	import java.beans.PropertyChangeEvent;
48	import java.beans.PropertyChangeListener;	48	import java.beans.PropertyChangeListener;




 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.api.search;

import org.junit.AfterClass;
import org.junit.Test;
import static org.junit.Assert.*;
import org.junit.BeforeClass;

/**
 *
 * @author mito
 */
public class SearchPatternTest {
    
    @Test
    public void testManuallyParse() throws Exception {
        String canString= "MrW-Test";
        SearchPattern sp = SearchPattern.parsePattern(canString);
        assertTrue(sp.isMatchCase());
        assertFalse(sp.isRegExp());
        assertTrue(sp.isWholeWords());

Lines 1-6 Link Here

(-)a/editor.lib2/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.editor.lib2/1	2	OpenIDE-Module: org.netbeans.modules.editor.lib2/1
3	OpenIDE-Module-Implementation-Version: 39	3	OpenIDE-Module-Implementation-Version: 40
4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/lib2/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/lib2/Bundle.properties
5	OpenIDE-Module-Layer: org/netbeans/modules/editor/lib2/resources/layer.xml	5	OpenIDE-Module-Layer: org/netbeans/modules/editor/lib2/resources/layer.xml
6	OpenIDE-Module-Needs: org.netbeans.modules.editor.actions	6	OpenIDE-Module-Needs: org.netbeans.modules.editor.actions

Lines 137-144 Link Here

(-)a/editor.lib2/src/org/netbeans/modules/editor/lib2/search/EditorFindSupport.java (+58 lines)
137		137
138	/** It's public only to keep backwards compatibility of the FindSupport class. */	138	/** It's public only to keep backwards compatibility of the FindSupport class. */
139	public static final String FIND_HISTORY_PROP = "find-history-prop"; //NOI18N	139	public static final String FIND_HISTORY_PROP = "find-history-prop"; //NOI18N
		140	public static final String REPLACE_HISTORY_PROP = "replace-history-prop"; //NOI18N
140	/** It's public only to keep backwards compatibility of the FindSupport class. */	141	/** It's public only to keep backwards compatibility of the FindSupport class. */
141	public static final String FIND_HISTORY_CHANGED_PROP = "find-history-changed-prop"; //NOI18N	142	public static final String FIND_HISTORY_CHANGED_PROP = "find-history-changed-prop"; //NOI18N
		143	public static final String REPLACE_HISTORY_CHANGED_PROP = "replace-history-changed-prop"; //NOI18N
142		144
143	/**	145	/**
144	* Default message 'importance' for messages from find and replace actions.	146	* Default message 'importance' for messages from find and replace actions.
Lines 162-167 Link Here
162		164
163	private SPW lastSelected;	165	private SPW lastSelected;
164	private List<SPW> historyList = new ArrayList<SPW>();	166	private List<SPW> historyList = new ArrayList<SPW>();
		167	private List<RP> replaceList = new ArrayList<RP>();
165		168
166	private EditorFindSupport() {	169	private EditorFindSupport() {
167	}	170	}
Lines 917-928 Link Here
917	// firePropertyChange(FIND_HISTORY_CHANGED_PROP,null,null);	920	// firePropertyChange(FIND_HISTORY_CHANGED_PROP,null,null);
918	}	921	}
919		922
		923	public void setReplaceHistory(List<RP> rpList){
		924	this.replaceList = new ArrayList<RP>(rpList);
		925	}
		926
920	public List<SPW> getHistory(){	927	public List<SPW> getHistory(){
921	if (historyList.isEmpty())	928	if (historyList.isEmpty())
922	firePropertyChange(FIND_HISTORY_CHANGED_PROP,null,null);	929	firePropertyChange(FIND_HISTORY_CHANGED_PROP,null,null);
923	return historyList;	930	return historyList;
924	}	931	}
925		932
		933	public List<RP> getReplaceHistory(){
		934	if (replaceList.isEmpty()) {
		935	firePropertyChange(REPLACE_HISTORY_CHANGED_PROP,null,null);
		936	}
		937	return replaceList;
		938	}
		939
926	public void setLastSelected(SPW spw){	940	public void setLastSelected(SPW spw){
927	this.lastSelected = spw;	941	this.lastSelected = spw;
928	Map<String, Object> props = getFindProperties();	942	Map<String, Object> props = getFindProperties();
Lines 942-947 Link Here
942	firePropertyChange(FIND_HISTORY_PROP, null, spw);	956	firePropertyChange(FIND_HISTORY_PROP, null, spw);
943	}	957	}
944		958
		959	public void addToReplaceHistory(RP rp) {
		960	if (rp == null) {
		961	return;
		962	}
		963	firePropertyChange(REPLACE_HISTORY_PROP, null, rp);
		964	}
		965
945	public final static class SPW{	966	public final static class SPW{
946	private String searchExpression;	967	private String searchExpression;
947	private boolean wholeWords;	968	private boolean wholeWords;
Lines 1010-1013 Link Here
1010	return sb.toString();	1031	return sb.toString();
1011	}	1032	}
1012	} // End of SPW class	1033	} // End of SPW class
		1034
		1035	public final static class RP {
		1036
		1037	private String replaceExpression;
		1038	private boolean preserveCase;
		1039
		1040	public RP(String replaceExpression, boolean preserveCase) {
		1041	this.replaceExpression = replaceExpression;
		1042	this.preserveCase = preserveCase;
		1043	}
		1044
		1045	public String getReplaceExpression() {
		1046	return replaceExpression;
		1047	}
		1048
		1049	public boolean isPreserveCase() {
		1050	return preserveCase;
		1051	}
		1052
		1053	@Override
		1054	public boolean equals(Object obj) {
		1055	if (!(obj instanceof RP)) {
		1056	return false;
		1057	}
		1058	RP sp = (RP) obj;
		1059	return (this.replaceExpression.equals(sp.getReplaceExpression())
		1060	&& this.preserveCase == sp.isPreserveCase());
		1061	}
		1062
		1063	@Override
		1064	public int hashCode() {
		1065	int result = 17;
		1066	result = 37 * result + (this.preserveCase ? 1 : 0);
		1067	result = 37 * result + this.replaceExpression.hashCode();
		1068	return result;
		1069	}
		1070	}
1013	}	1071	}

Lines 1-3 Link Here

(-)a/editor.search/nbproject/project.properties (-1 / +1 lines)
1	javac.source=1.6	1	javac.source=1.6
2	javac.compilerargs=-Xlint -Xlint:-serial	2	javac.compilerargs=-Xlint -Xlint:-serial
3	spec.version.base=1.9.0	3	spec.version.base=1.10.0

Lines 6-11 Link Here

(-)a/editor.search/nbproject/project.xml (+8 lines)
6	<code-name-base>org.netbeans.modules.editor.search</code-name-base>	6	<code-name-base>org.netbeans.modules.editor.search</code-name-base>
7	<module-dependencies>	7	<module-dependencies>
8	<dependency>	8	<dependency>
		9	<code-name-base>org.netbeans.api.search</code-name-base>
		10	<build-prerequisite/>
		11	<compile-dependency/>
		12	<run-dependency>
		13	<specification-version>1.7</specification-version>
		14	</run-dependency>
		15	</dependency>
		16	<dependency>
9	<code-name-base>org.netbeans.modules.editor</code-name-base>	17	<code-name-base>org.netbeans.modules.editor</code-name-base>
10	<build-prerequisite/>	18	<build-prerequisite/>
11	<compile-dependency/>	19	<compile-dependency/>




    }

    void updateReplaceComboBoxHistory(String incrementalSearchText) {
        EditorFindSupport.getInstance().addToReplaceHistory(new EditorFindSupport.RP(incrementalSearchText, preserveCaseCheckBox.isSelected()));
        // Add the text to the top of the list
        for (int i = replaceComboBox.getItemCount() - 1; i >= 0; i--) {
            String item = (String) replaceComboBox.getItemAt(i);

    public void gainFocus() {
        if (!isVisible()) {
            changeSearchBarToBePartOfReplaceBar();
            setVisible(true);
            SearchComboBoxEditor.changeToOneLineEditorPane((JEditorPane) replaceTextField);
            addEnterKeystrokeReplaceTo(replaceTextField);
            String lastReplace = replaceTextField.getText();
            MutableComboBoxModel comboBoxModelIncSearch = ((MutableComboBoxModel) replaceComboBox.getModel());
            for (int i = comboBoxModelIncSearch.getSize() - 1; i >= 0; i--) {
                comboBoxModelIncSearch.removeElementAt(i);
            }
            for (EditorFindSupport.RP rp : EditorFindSupport.getInstance().getReplaceHistory()) {
                comboBoxModelIncSearch.addElement(rp.getReplaceExpression());
            }
            replaceTextField.setText(lastReplace);
            setVisible(true);
        }
        searchBar.gainFocus();
        searchBar.getIncSearchTextField().requestFocusInWindow();

Lines 44-49 Link Here

(-)a/editor.search/src/org/netbeans/modules/editor/search/SearchBar.java (+85 lines)
44	import java.beans.PropertyChangeEvent;	44	import java.beans.PropertyChangeEvent;
45	import java.beans.PropertyChangeListener;	45	import java.beans.PropertyChangeListener;
46	import java.lang.ref.WeakReference;	46	import java.lang.ref.WeakReference;
		47	import java.util.ArrayList;
47	import java.util.Arrays;	48	import java.util.Arrays;
48	import java.util.LinkedList;	49	import java.util.LinkedList;
49	import java.util.List;	50	import java.util.List;
Lines 64-69 Link Here
64	import org.netbeans.api.editor.mimelookup.MimeLookup;	65	import org.netbeans.api.editor.mimelookup.MimeLookup;
65	import org.netbeans.api.editor.mimelookup.MimePath;	66	import org.netbeans.api.editor.mimelookup.MimePath;
66	import org.netbeans.api.editor.settings.SimpleValueNames;	67	import org.netbeans.api.editor.settings.SimpleValueNames;
		68	import org.netbeans.api.search.ReplacePattern;
		69	import org.netbeans.api.search.SearchHistory;
		70	import org.netbeans.api.search.SearchPattern;
67	import org.netbeans.editor.BaseDocument;	71	import org.netbeans.editor.BaseDocument;
68	import org.netbeans.editor.BaseKit;	72	import org.netbeans.editor.BaseKit;
69	import org.netbeans.editor.MultiKeymap;	73	import org.netbeans.editor.MultiKeymap;
Lines 140-145 Link Here
140		144
141	@SuppressWarnings("unchecked")	145	@SuppressWarnings("unchecked")
142	private SearchBar() {	146	private SearchBar() {
		147	loadSearchHistory();
143	addEscapeKeystrokeFocusBackTo(this);	148	addEscapeKeystrokeFocusBackTo(this);
144	setLayout(new BoxLayout(this, BoxLayout.LINE_AXIS));	149	setLayout(new BoxLayout(this, BoxLayout.LINE_AXIS));
145	setFocusCycleRoot(true);	150	setFocusCycleRoot(true);
Lines 236-241 Link Here
236	setVisible(false);	241	setVisible(false);
237	usageLogging();	242	usageLogging();
238	}	243	}
		244
		245	private static class SearchHistoryUtility {
		246
		247	public static List<EditorFindSupport.SPW> convertFromSearchHistoryToEditorFindSupport(List<SearchPattern> searchPatterns) {
		248	List<EditorFindSupport.SPW> history = new ArrayList<EditorFindSupport.SPW>();
		249	for (int i = 0; i < searchPatterns.size(); i++) {
		250	SearchPattern sptr = searchPatterns.get(i);
		251	EditorFindSupport.SPW spwrap = new EditorFindSupport.SPW(sptr.getSearchExpression(),
		252	sptr.isWholeWords(), sptr.isMatchCase(), sptr.isRegExp());
		253	history.add(spwrap);
		254	}
		255	return history;
		256	}
		257
		258	public static List<EditorFindSupport.RP> convertFromReplaceHistoryToEditorFindSupport(List<ReplacePattern> replacePatterns) {
		259	List<EditorFindSupport.RP> history = new ArrayList<EditorFindSupport.RP>();
		260	for (int i = 0; i < replacePatterns.size(); i++) {
		261	ReplacePattern rp = replacePatterns.get(i);
		262	EditorFindSupport.RP spwrap = new EditorFindSupport.RP(rp.getReplaceExpression(), rp.isPreserveCase());
		263	history.add(spwrap);
		264	}
		265	return history;
		266	}
		267	}
		268	private static PropertyChangeListener searchSelectedPatternListener;
		269	private static PropertyChangeListener editorHistoryChangeListener;
		270
		271	private static void loadSearchHistory() {
		272	searchSelectedPatternListener = new PropertyChangeListener() {
		273	@Override
		274	public void propertyChange(PropertyChangeEvent evt) {
		275	if (evt == null) {
		276	return;
		277	}
		278	if (SearchHistory.ADD_TO_HISTORY.equals(evt.getPropertyName())) {
		279	EditorFindSupport.getInstance().setHistory(
		280	SearchHistoryUtility.convertFromSearchHistoryToEditorFindSupport(SearchHistory.getDefault().getSearchPatterns()));
		281	}
		282
		283	if (SearchHistory.ADD_TO_REPLACE.equals(evt.getPropertyName())) {
		284	EditorFindSupport.getInstance().setReplaceHistory(
		285	SearchHistoryUtility.convertFromReplaceHistoryToEditorFindSupport(SearchHistory.getDefault().getReplacePatterns()));
		286	}
		287	}
		288	};
		289
		290	editorHistoryChangeListener = new PropertyChangeListener() {
		291	@Override
		292	public void propertyChange(PropertyChangeEvent evt) {
		293	if (evt == null) {
		294	return;
		295	}
		296	if (EditorFindSupport.FIND_HISTORY_PROP.equals(evt.getPropertyName())) {
		297	EditorFindSupport.SPW spw = (EditorFindSupport.SPW) evt.getNewValue();
		298	if (spw == null \|\| spw.getSearchExpression() == null \|\| "".equals(spw.getSearchExpression())) { //NOI18N
		299	return;
		300	}
		301	SearchPattern sp = SearchPattern.create(spw.getSearchExpression(),
		302	spw.isWholeWords(), spw.isMatchCase(), spw.isRegExp());
		303	SearchHistory.getDefault().add(sp);
		304	} else if (EditorFindSupport.FIND_HISTORY_CHANGED_PROP.equals(evt.getPropertyName())) {
		305	EditorFindSupport.getInstance().setHistory(
		306	SearchHistoryUtility.convertFromSearchHistoryToEditorFindSupport(SearchHistory.getDefault().getSearchPatterns()));
		307	} else if (EditorFindSupport.REPLACE_HISTORY_PROP.equals(evt.getPropertyName())) {
308	EditorFindSupport.RP rp = (EditorFindSupport.RP) evt.getNewValue();
309	if (rp == null \|\| rp.getReplaceExpression() == null \|\| "".equals(rp.getReplaceExpression())) { //NOI18N
310	return;
311	}
312	ReplacePattern replacePattern = ReplacePattern.create(rp.getReplaceExpression(), rp.isPreserveCase());
313	SearchHistory.getDefault().addReplace(replacePattern);
314	} else if (EditorFindSupport.REPLACE_HISTORY_CHANGED_PROP.equals(evt.getPropertyName())) {
315	EditorFindSupport.getInstance().setReplaceHistory(
316	SearchHistoryUtility.convertFromReplaceHistoryToEditorFindSupport(SearchHistory.getDefault().getReplacePatterns()));
317	}
318	}
319	};
320
321	SearchHistory.getDefault().addPropertyChangeListener(searchSelectedPatternListener);
322	EditorFindSupport.getInstance().addPropertyChangeListener(editorHistoryChangeListener);
323	}
239		324
240	private static void usageLogging() {	325	private static void usageLogging() {
241	Logger logger = Logger.getLogger("org.netbeans.ui.metrics.editor"); // NOI18N	326	Logger logger = Logger.getLogger("org.netbeans.ui.metrics.editor"); // NOI18N

Lines 48-53 Link Here

(-)a/editor.search/src/org/netbeans/modules/editor/search/completion/SearchCompletion.java (+8 lines)
48	import javax.swing.text.JTextComponent;	48	import javax.swing.text.JTextComponent;
49	import org.netbeans.api.editor.mimelookup.MimeRegistration;	49	import org.netbeans.api.editor.mimelookup.MimeRegistration;
50	import org.netbeans.modules.editor.lib2.search.EditorFindSupport;	50	import org.netbeans.modules.editor.lib2.search.EditorFindSupport;
		51	import org.netbeans.modules.editor.lib2.search.EditorFindSupport.RP;
51	import org.netbeans.modules.editor.lib2.search.EditorFindSupport.SPW;	52	import org.netbeans.modules.editor.lib2.search.EditorFindSupport.SPW;
52	import org.netbeans.modules.editor.search.SearchBar;	53	import org.netbeans.modules.editor.search.SearchBar;
53	import org.netbeans.modules.editor.search.SearchNbEditorKit;	54	import org.netbeans.modules.editor.search.SearchNbEditorKit;
Lines 109-114 Link Here
109	results.add(searchCompletionItem);	110	results.add(searchCompletionItem);
110	}	111	}
111	}	112	}
		113	for (RP rp : EditorFindSupport.getInstance().getReplaceHistory()) {
		114	String s = rp.getReplaceExpression().trim();
		115	if (s.toLowerCase().startsWith(queryText) && s.length() != queryText.length()) {
		116	SearchCompletionItem searchCompletionItem = new SearchCompletionItem(s);
		117	results.add(searchCompletionItem);
		118	}
		119	}
112	}	120	}
113	if (resultSet != null) { // resultSet can be null only in tests!	121	if (resultSet != null) { // resultSet can be null only in tests!
114	resultSet.addAllItems(results);	122	resultSet.addAllItems(results);

Lines 42-48 Link Here

(-)a/editor/nbproject/project.properties (-1 / +1 lines)
42		42
43	javac.compilerargs=-Xlint:unchecked	43	javac.compilerargs=-Xlint:unchecked
44	javac.source=1.6	44	javac.source=1.6
45	spec.version.base=1.69.0	45	spec.version.base=1.70.0
46	is.autoload=true	46	is.autoload=true
47		47
48	javadoc.arch=${basedir}/arch.xml	48	javadoc.arch=${basedir}/arch.xml




                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.api.search</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>1.0</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.editor.fold</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>




import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;

import javax.swing.text.rtf.RTFEditorKit;
import org.netbeans.api.editor.mimelookup.MimeLookup;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.search.SearchHistory;
import org.netbeans.api.search.SearchPattern;
import org.netbeans.editor.AnnotationType;
import org.netbeans.editor.AnnotationTypes;
import org.netbeans.editor.BaseDocument;

import org.netbeans.modules.editor.lib.EditorPackageAccessor;
import org.netbeans.modules.editor.lib2.actions.EditorRegistryWatcher;
import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;
import org.netbeans.modules.editor.lib2.search.EditorFindSupport;
import org.netbeans.modules.editor.options.AnnotationTypesFolder;
import org.openide.cookies.EditorCookie;
import org.openide.filesystems.FileObject;

    
    private static final boolean debug = Boolean.getBoolean("netbeans.debug.editor.kits");

    private static class SearchHistoryUtility {
        public static List<EditorFindSupport.SPW> convertFromSearchHistoryToEditorFindSupport(List<SearchPattern> searchPatterns) {
            List<EditorFindSupport.SPW> history = new ArrayList<EditorFindSupport.SPW>();
            for (int i = 0; i < searchPatterns.size(); i++) {
                SearchPattern sptr = searchPatterns.get(i);
                EditorFindSupport.SPW spwrap = new EditorFindSupport.SPW(sptr.getSearchExpression(),
                        sptr.isWholeWords(), sptr.isMatchCase(), sptr.isRegExp());
                history.add(spwrap);
            }
            return history;
        }
    }
    private PropertyChangeListener searchSelectedPatternListener;
    private PropertyChangeListener editorHistoryChangeListener;
    private PropertyChangeListener topComponentRegistryListener;

    /** Module installed again. */


        // ------------------------------------------------------------
        
         searchSelectedPatternListener = new PropertyChangeListener(){
             
            @Override
             public void propertyChange(PropertyChangeEvent evt){
                 if (evt == null)
                     return;             
                 if (SearchHistory.ADD_TO_HISTORY.equals(evt.getPropertyName())){
                     EditorFindSupport.getInstance().setHistory(
                             SearchHistoryUtility.convertFromSearchHistoryToEditorFindSupport(SearchHistory.getDefault().getSearchPatterns()));
                 }
             }
         };

        editorHistoryChangeListener = new PropertyChangeListener() {

            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                if (evt == null) {
                    return;
                }
                if (EditorFindSupport.FIND_HISTORY_PROP.equals(evt.getPropertyName())) {
                    EditorFindSupport.SPW spw = (EditorFindSupport.SPW) evt.getNewValue();
                    if (spw == null || spw.getSearchExpression() == null || "".equals(spw.getSearchExpression())) { //NOI18N
                        return;
                    }
                    SearchPattern sp = SearchPattern.create(spw.getSearchExpression(),
                            spw.isWholeWords(), spw.isMatchCase(), spw.isRegExp());
                    SearchHistory.getDefault().add(sp);
                } else if (EditorFindSupport.FIND_HISTORY_CHANGED_PROP.equals(evt.getPropertyName())) {
                    EditorFindSupport.getInstance().setHistory(
                             SearchHistoryUtility.convertFromSearchHistoryToEditorFindSupport(SearchHistory.getDefault().getSearchPatterns()));
                }                       
            }
        };

        SearchHistory.getDefault().addPropertyChangeListener(searchSelectedPatternListener);
        EditorFindSupport.getInstance().addPropertyChangeListener(editorHistoryChangeListener);
        if (topComponentRegistryListener == null) {
            topComponentRegistryListener = new PropertyChangeListener() {
                @Override

Return to bug 221993

Lines 105-110 Link Here

(-)a/api.search/apichanges.xml (+21 lines)
105	<!-- ACTUAL CHANGES BEGIN HERE: -->	105	<!-- ACTUAL CHANGES BEGIN HERE: -->
106		106
107	<changes>	107	<changes>
		108	<change id="ReplaceHistory">
		109	<api name="api.search"/>
		110	<summary>Added ReplacePattern and replace history to SearchHistory class</summary>
		111	<version major="1" minor="1.8"/>
		112	<date day="20" month="11" year="2012"/>
		113	<author login="mkristofic"/>
		114	<compatibility addition="yes"/>
		115	<description>
		116	<p>
		117	Search History has two new methods: addReplace() and getReplacePatterns().
		118	It has one more property name ADD_TO_REPLACE for firing changes in replacepatternlist.
		119	Replace implementation is identical to Search history with Search Patterns..
		120	</p>
		121	<p>
		122	New ReplacePattern has two variables - replaceExpression and preserveCase. It is a wrap class for replace expression.
		123	</p>
		124	</description>
		125	<class package="org.netbeans.api.search" name="ReplacePattern"/>
		126	<class package="org.netbeans.api.search" name="SearchHistory"/>
		127	</change>
		128
108	<change id="SearchResultsDisplayer-closed">	129	<change id="SearchResultsDisplayer-closed">
109	<api name="api.search"/>	130	<api name="api.search"/>
110	<summary>Added method SearchResultsDisplayer.closed()</summary>	131	<summary>Added method SearchResultsDisplayer.closed()</summary>

Lines 39-72 Link Here

(-)a/o.openidex.util/test/unit/src/org/openidex/search/SearchPatternTest.java (-17 / +18 lines)
39	*	39	*
40	* Portions Copyrighted 2012 Sun Microsystems, Inc.	40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
41	*/	41	*/
42	package org.openidex.search;	42	package org.netbeans.api.search;
43		43
44	import org.junit.AfterClass;
45	import org.junit.Test;	44	import org.junit.Test;
46	import static org.junit.Assert.*;	45	import static org.junit.Assert.*;
47	import org.junit.BeforeClass;
48		46
49	/**	47
50	*	48	public class ReplacePatternTest {
51	* @author mito
52	*/
53	public class SearchPatternTest {
54		49
55	@Test	50	@Test
56	public void testManuallyParse() throws Exception {	51	public void testManuallyParse() throws Exception {
57	String canString= "MrW-Test";	52	String canString= "P-Test";
58	SearchPattern sp = SearchPattern.parseSearchPattern(canString);	53	ReplacePattern rp = ReplacePattern.parsePattern(canString);
59	assertTrue(sp.isMatchCase());	54	assertTrue(rp.isPreserveCase());
60	assertFalse(sp.isRegExp());	55	assertEquals("Test", rp.getReplaceExpression());
61	assertTrue(sp.isWholeWords());	56
62	assertEquals("Test", sp.getSearchExpression());	57	canString= "p--Test2";
		58	rp = ReplacePattern.parsePattern(canString);
		59	assertFalse(rp.isPreserveCase());
		60	assertEquals("-Test2", rp.getReplaceExpression());
63	}	61	}
64		62
65	@Test	63	@Test
66	public void testManuallyCanString() throws Exception {	64	public void testManuallyCanString() throws Exception {
67	SearchPattern sp = SearchPattern.create("ta", true, false, true);	65	ReplacePattern rp = ReplacePattern.create("ta", true);
68	String canString = sp.toCanonicalString();	66	String canString = rp.toCanonicalString();
		67	assertEquals("P-ta", canString);
69		68
70	assertEquals("mRW-ta", canString);	69	rp = ReplacePattern.create("pa", false);
		70	canString = rp.toCanonicalString();
		71	assertEquals("p-pa", canString);
71	}	72	}
72	}	73	}

Lines 276-281 Link Here

(-)a/editor.search/src/org/netbeans/modules/editor/search/ReplaceBar.java (-1 / +11 lines)
276	}	276	}
277		277
278	void updateReplaceComboBoxHistory(String incrementalSearchText) {	278	void updateReplaceComboBoxHistory(String incrementalSearchText) {
		279	EditorFindSupport.getInstance().addToReplaceHistory(new EditorFindSupport.RP(incrementalSearchText, preserveCaseCheckBox.isSelected()));
279	// Add the text to the top of the list	280	// Add the text to the top of the list
280	for (int i = replaceComboBox.getItemCount() - 1; i >= 0; i--) {	281	for (int i = replaceComboBox.getItemCount() - 1; i >= 0; i--) {
281	String item = (String) replaceComboBox.getItemAt(i);	282	String item = (String) replaceComboBox.getItemAt(i);
Lines 357-365 Link Here
357	public void gainFocus() {	358	public void gainFocus() {
358	if (!isVisible()) {	359	if (!isVisible()) {
359	changeSearchBarToBePartOfReplaceBar();	360	changeSearchBarToBePartOfReplaceBar();
360	setVisible(true);
361	SearchComboBoxEditor.changeToOneLineEditorPane((JEditorPane) replaceTextField);	361	SearchComboBoxEditor.changeToOneLineEditorPane((JEditorPane) replaceTextField);
362	addEnterKeystrokeReplaceTo(replaceTextField);	362	addEnterKeystrokeReplaceTo(replaceTextField);
		363	String lastReplace = replaceTextField.getText();
		364	MutableComboBoxModel comboBoxModelIncSearch = ((MutableComboBoxModel) replaceComboBox.getModel());
		365	for (int i = comboBoxModelIncSearch.getSize() - 1; i >= 0; i--) {
		366	comboBoxModelIncSearch.removeElementAt(i);
		367	}
		368	for (EditorFindSupport.RP rp : EditorFindSupport.getInstance().getReplaceHistory()) {
		369	comboBoxModelIncSearch.addElement(rp.getReplaceExpression());
		370	}
		371	replaceTextField.setText(lastReplace);
		372	setVisible(true);
363	}	373	}
364	searchBar.gainFocus();	374	searchBar.gainFocus();
365	searchBar.getIncSearchTextField().requestFocusInWindow();	375	searchBar.getIncSearchTextField().requestFocusInWindow();

Lines 59-72 Link Here

(-)a/editor/nbproject/project.xml (-8 lines)
59	</run-dependency>	59	</run-dependency>
60	</dependency>	60	</dependency>
61	<dependency>	61	<dependency>
62	<code-name-base>org.netbeans.api.search</code-name-base>
63	<build-prerequisite/>
64	<compile-dependency/>
65	<run-dependency>
66	<specification-version>1.0</specification-version>
67	</run-dependency>
68	</dependency>
69	<dependency>
70	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>	62	<code-name-base>org.netbeans.modules.editor.fold</code-name-base>
71	<build-prerequisite/>	63	<build-prerequisite/>
72	<compile-dependency/>	64	<compile-dependency/>

Lines 50-60 Link Here

(-)a/editor/src/org/netbeans/modules/editor/EditorModule.java (-55 lines)
50	import java.io.IOException;	50	import java.io.IOException;
51	import java.lang.reflect.Field;	51	import java.lang.reflect.Field;
52	import java.lang.reflect.Method;	52	import java.lang.reflect.Method;
53	import java.util.ArrayList;
54	import java.util.HashSet;	53	import java.util.HashSet;
55	import java.util.Hashtable;	54	import java.util.Hashtable;
56	import java.util.Iterator;	55	import java.util.Iterator;
57	import java.util.List;
58	import java.util.Map;	56	import java.util.Map;
59	import java.util.concurrent.atomic.AtomicBoolean;	57	import java.util.concurrent.atomic.AtomicBoolean;
60	import java.util.logging.Level;	58	import java.util.logging.Level;
Lines 69-76 Link Here
69	import javax.swing.text.rtf.RTFEditorKit;	67	import javax.swing.text.rtf.RTFEditorKit;
70	import org.netbeans.api.editor.mimelookup.MimeLookup;	68	import org.netbeans.api.editor.mimelookup.MimeLookup;
71	import org.netbeans.api.editor.mimelookup.MimePath;	69	import org.netbeans.api.editor.mimelookup.MimePath;
72	import org.netbeans.api.search.SearchHistory;
73	import org.netbeans.api.search.SearchPattern;
74	import org.netbeans.editor.AnnotationType;	70	import org.netbeans.editor.AnnotationType;
75	import org.netbeans.editor.AnnotationTypes;	71	import org.netbeans.editor.AnnotationTypes;
76	import org.netbeans.editor.BaseDocument;	72	import org.netbeans.editor.BaseDocument;
Lines 81-87 Link Here
81	import org.netbeans.modules.editor.lib.EditorPackageAccessor;	77	import org.netbeans.modules.editor.lib.EditorPackageAccessor;
82	import org.netbeans.modules.editor.lib2.actions.EditorRegistryWatcher;	78	import org.netbeans.modules.editor.lib2.actions.EditorRegistryWatcher;
83	import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;	79	import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;
84	import org.netbeans.modules.editor.lib2.search.EditorFindSupport;
85	import org.netbeans.modules.editor.options.AnnotationTypesFolder;	80	import org.netbeans.modules.editor.options.AnnotationTypesFolder;
86	import org.openide.cookies.EditorCookie;	81	import org.openide.cookies.EditorCookie;
87	import org.openide.filesystems.FileObject;	82	import org.openide.filesystems.FileObject;
Lines 113-132 Link Here
113		108
114	private static final boolean debug = Boolean.getBoolean("netbeans.debug.editor.kits");	109	private static final boolean debug = Boolean.getBoolean("netbeans.debug.editor.kits");
115		110
116	private static class SearchHistoryUtility {
117	public static List<EditorFindSupport.SPW> convertFromSearchHistoryToEditorFindSupport(List<SearchPattern> searchPatterns) {
118	List<EditorFindSupport.SPW> history = new ArrayList<EditorFindSupport.SPW>();
119	for (int i = 0; i < searchPatterns.size(); i++) {
120	SearchPattern sptr = searchPatterns.get(i);
121	EditorFindSupport.SPW spwrap = new EditorFindSupport.SPW(sptr.getSearchExpression(),
122	sptr.isWholeWords(), sptr.isMatchCase(), sptr.isRegExp());
123	history.add(spwrap);
124	}
125	return history;
126	}
127	}
128	private PropertyChangeListener searchSelectedPatternListener;
129	private PropertyChangeListener editorHistoryChangeListener;
130	private PropertyChangeListener topComponentRegistryListener;	111	private PropertyChangeListener topComponentRegistryListener;
131		112
132	/** Module installed again. */	113	/** Module installed again. */
Lines 228-270 Link Here
228		209
229	// ------------------------------------------------------------	210	// ------------------------------------------------------------
230		211
231	searchSelectedPatternListener = new PropertyChangeListener(){
232
233	@Override
234	public void propertyChange(PropertyChangeEvent evt){
235	if (evt == null)
236	return;
237	if (SearchHistory.ADD_TO_HISTORY.equals(evt.getPropertyName())){
238	EditorFindSupport.getInstance().setHistory(
239	SearchHistoryUtility.convertFromSearchHistoryToEditorFindSupport(SearchHistory.getDefault().getSearchPatterns()));
240	}
241	}
242	};
243		212
244	editorHistoryChangeListener = new PropertyChangeListener() {
245
246	@Override
247	public void propertyChange(PropertyChangeEvent evt) {
248	if (evt == null) {
249	return;
250	}
251	if (EditorFindSupport.FIND_HISTORY_PROP.equals(evt.getPropertyName())) {
252	EditorFindSupport.SPW spw = (EditorFindSupport.SPW) evt.getNewValue();
253	if (spw == null \|\| spw.getSearchExpression() == null \|\| "".equals(spw.getSearchExpression())) { //NOI18N
254	return;
255	}
256	SearchPattern sp = SearchPattern.create(spw.getSearchExpression(),
257	spw.isWholeWords(), spw.isMatchCase(), spw.isRegExp());
258	SearchHistory.getDefault().add(sp);
259	} else if (EditorFindSupport.FIND_HISTORY_CHANGED_PROP.equals(evt.getPropertyName())) {
260	EditorFindSupport.getInstance().setHistory(
261	SearchHistoryUtility.convertFromSearchHistoryToEditorFindSupport(SearchHistory.getDefault().getSearchPatterns()));
262	}
263	}
264	};
265
266	SearchHistory.getDefault().addPropertyChangeListener(searchSelectedPatternListener);
267	EditorFindSupport.getInstance().addPropertyChangeListener(editorHistoryChangeListener);
268	if (topComponentRegistryListener == null) {	213	if (topComponentRegistryListener == null) {
269	topComponentRegistryListener = new PropertyChangeListener() {	214	topComponentRegistryListener = new PropertyChangeListener() {
270	@Override	215	@Override