org.fife.ui.rtextarea.SearchContext Maven / Gradle / Ivy
The newest version!
/*
* 02/17/2012
*
* SearchContext.java - Container for options of a search/replace operation.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.rtextarea;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
/**
* Contains information about a find/replace operation. Applications can
* keep an instance of this class around and use it to maintain the user's
* selection for options such as "match case," "regular expression," etc.,
* between search operations. They can then pass the instance as a parameter
* to the public {@link SearchEngine} methods to do the actual searching.
*
* @author Robert Futrell
* @version 2.0
* @see SearchEngine
*/
public class SearchContext implements Cloneable {
/** Fired when the "search for" property is modified. */
public static final String PROPERTY_SEARCH_FOR = "Search.searchFor";
/** Fired when the "replace with" property is modified. */
public static final String PROPERTY_REPLACE_WITH = "Search.replaceWith";
/** Fired when the "match case" property is toggled. */
public static final String PROPERTY_MATCH_CASE = "Search.MatchCase";
/** Fired when the "whole word" property is toggled. */
public static final String PROPERTY_MATCH_WHOLE_WORD = "Search.MatchWholeWord";
/** Fired when search direction is toggled. */
public static final String PROPERTY_SEARCH_FORWARD = "Search.Forward";
/** Fired when "search in selection" is toggled (not currently supported). */
public static final String PROPERTY_SELECTION_ONLY = "Search.SelectionOnly";
/** Fired when "use regular expressions" is toggled. */
public static final String PROPERTY_USE_REGEX = "Search.UseRegex";
/** Fired when the user toggles the "Mark All" property. */
public static final String PROPERTY_MARK_ALL = "Search.MarkAll";
private String searchFor;
private String replaceWith;
private boolean forward;
private boolean matchCase;
private boolean wholeWord;
private boolean regex;
private boolean selectionOnly;
private boolean markAll;
private PropertyChangeSupport support;
/**
* Creates a new search context. Specifies a forward search,
* case-insensitive, not whole-word, not a regular expression.
*/
public SearchContext() {
this(null);
}
/**
* Creates a new search context. Specifies a forward search,
* case-insensitive, not whole-word, not a regular expression.
*
* @param searchFor The text to search for.
*/
public SearchContext(String searchFor) {
this(searchFor, false);
}
/**
* Creates a new search context. Specifies a forward search, not
* whole-word, not a regular expression.
*
* @param searchFor The text to search for.
* @param matchCase Whether to do a case-sensitive search.
*/
public SearchContext(String searchFor, boolean matchCase) {
support = new PropertyChangeSupport(this);
this.searchFor = searchFor;
this.matchCase = matchCase;
markAll = true;
forward = true;
}
/**
* Adds a property change listener to this context.
*
* @param l The new listener.
* @see #removePropertyChangeListener(PropertyChangeListener)
*/
public void addPropertyChangeListener(PropertyChangeListener l) {
support.addPropertyChangeListener(l);
}
@Override
public SearchContext clone() {
try {
SearchContext context = null;
context = (SearchContext)super.clone();
// Don't copy over listeners
context.support = new PropertyChangeSupport(context);
return context;
} catch (CloneNotSupportedException cnse) { // Never happens
throw new RuntimeException("Should never happen", cnse);
}
}
protected void firePropertyChange(String property, boolean oldValue,
boolean newValue) {
support.firePropertyChange(property, oldValue, newValue);
}
protected void firePropertyChange(String property, String oldValue,
String newValue) {
support.firePropertyChange(property, oldValue, newValue);
}
/**
* Returns whether "mark all" should be selected or enabled.
*
* @return Whether "mark all" should be enabled.
* @see #setMarkAll(boolean)
*/
public boolean getMarkAll() {
return markAll;
}
/**
* Returns whether case should be honored while searching.
*
* @return Whether case should be honored.
* @see #setMatchCase(boolean)
*/
public boolean getMatchCase() {
return matchCase;
}
/**
* Returns the text to replace with, if doing a replace operation.
*
* @return The text to replace with.
* @see #setReplaceWith(String)
* @see #getSearchFor()
*/
public String getReplaceWith() {
return replaceWith;
}
/**
* Returns the text to search for.
*
* @return The text to search for.
* @see #setSearchFor(String)
* @see #getReplaceWith()
*/
public String getSearchFor() {
return searchFor;
}
/**
* Returns whether the search should be forward through the text (vs.
* backwards).
*
* @return Whether we should search forwards.
* @see #setSearchForward(boolean)
*/
public boolean getSearchForward() {
return forward;
}
/**
* Returns whether the search should only be done in the selected text.
* This flag is currently not supported.
*
* @return Whether only the selected text should be searched.
* @see #setSearchSelectionOnly(boolean)
*/
public boolean getSearchSelectionOnly() {
return selectionOnly;
}
/**
* Returns whether only "whole word" matches should be returned. A match
* is considered to be "whole word" if the character on either side of the
* matched text is a non-word character, or if there is no character on
* one side of the word, such as when it's at the beginning or end of a
* line.
*
* @return Whether only "whole word" matches should be returned.
* @see #setWholeWord(boolean)
*/
public boolean getWholeWord() {
return wholeWord;
}
/**
* Returns whether a regular expression search should be done.
*
* @return Whether a regular expression search should be done.
* @see #setRegularExpression(boolean)
*/
public boolean isRegularExpression() {
return regex;
}
/**
* Removes a property change listener from this context.
*
* @param l The listener to remove.
* @see #addPropertyChangeListener(PropertyChangeListener)
*/
public void removePropertyChangeListener(PropertyChangeListener l) {
support.removePropertyChangeListener(l);
}
/**
* Sets whether "mark all" should be selected or enabled. This method
* fires property change events of type {@link #PROPERTY_MARK_ALL}.
*
* @param markAll Whether "mark all" should be enabled.
* @see #getMarkAll()
*/
public void setMarkAll(boolean markAll) {
if (markAll!=this.markAll) {
this.markAll = markAll;
firePropertyChange(PROPERTY_MARK_ALL, !markAll, markAll);
}
}
/**
* Sets whether case should be honored while searching. This method
* fires a property change event of type {@link #PROPERTY_MATCH_CASE}.
*
* @param matchCase Whether case should be honored.
* @see #getMatchCase()
*/
public void setMatchCase(boolean matchCase) {
if (matchCase!=this.matchCase) {
this.matchCase = matchCase;
firePropertyChange(PROPERTY_MATCH_CASE, !matchCase, matchCase);
}
}
/**
* Sets whether a regular expression search should be done.This method
* fires a property change event of type {@link #PROPERTY_USE_REGEX}
*
* @param regex Whether a regular expression search should be done.
* @see #isRegularExpression()
*/
public void setRegularExpression(boolean regex) {
if (regex!=this.regex) {
this.regex = regex;
firePropertyChange(PROPERTY_USE_REGEX, !regex, regex);
}
}
/**
* Sets the text to replace with, if doing a replace operation. This
* method fires a property change event of type
* {@link #PROPERTY_REPLACE_WITH}.
*
* @param replaceWith The text to replace with.
* @see #getReplaceWith()
* @see #setSearchFor(String)
*/
public void setReplaceWith(String replaceWith) {
if ((replaceWith==null && this.replaceWith!=null) ||
(replaceWith!=null && !replaceWith.equals(this.replaceWith))) {
String old = this.replaceWith;
this.replaceWith = replaceWith;
firePropertyChange(PROPERTY_REPLACE_WITH, old, replaceWith);
}
}
/**
* Sets the text to search for. This method fires a property change
* event of type {@link #PROPERTY_SEARCH_FOR}.
*
* @param searchFor The text to search for.
* @see #getSearchFor()
* @see #setReplaceWith(String)
*/
public void setSearchFor(String searchFor) {
if ((searchFor==null && this.searchFor!=null) ||
(searchFor!=null && !searchFor.equals(this.searchFor))) {
String old = this.searchFor;
this.searchFor = searchFor;
firePropertyChange(PROPERTY_SEARCH_FOR, old, searchFor);
}
}
/**
* Sets whether the search should be forward through the text (vs.
* backwards). This method fires a property change event of type
* {@link #PROPERTY_SEARCH_FORWARD}.
*
* @param forward Whether we should search forwards.
* @see #getSearchForward()
*/
public void setSearchForward(boolean forward) {
if (forward!=this.forward) {
this.forward = forward;
firePropertyChange(PROPERTY_SEARCH_FORWARD, !forward, forward);
}
}
/**
* Sets whether only the selected text should be searched. This method
* fires a property change event of type {@link #PROPERTY_SELECTION_ONLY}.
*
*
* This flag is currently not supported. Calling this method will throw
* an {@link UnsupportedOperationException} until it is implemented.
*
* @param selectionOnly Whether only selected text should be searched.
* @see #getSearchSelectionOnly()
*/
public void setSearchSelectionOnly(boolean selectionOnly) {
if (selectionOnly!=this.selectionOnly) {
this.selectionOnly = selectionOnly;
firePropertyChange(PROPERTY_SELECTION_ONLY,
!selectionOnly, selectionOnly);
if (selectionOnly) {
throw new UnsupportedOperationException(
"Searching in selection is not currently supported");
}
}
}
/**
* Sets whether only "whole word" matches should be returned. A match
* is considered to be "whole word" if the character on either side of the
* matched text is a non-word character, or if there is no character on
* one side of the word, such as when it's at the beginning or end of a
* line.This method fires a property change event of type
* {@link #PROPERTY_MATCH_WHOLE_WORD}.
*
* @param wholeWord Whether only "whole word" matches should be returned.
* @see #getWholeWord()
*/
public void setWholeWord(boolean wholeWord) {
if (wholeWord!=this.wholeWord) {
this.wholeWord = wholeWord;
firePropertyChange(PROPERTY_MATCH_WHOLE_WORD, !wholeWord,wholeWord);
}
}
@Override
public String toString() {
return "[SearchContext: " +
"searchFor='" + getSearchFor() + "'" +
", replaceWith='" + getReplaceWith() + "'" +
", matchCase=" + getMatchCase() +
", wholeWord=" + getWholeWord() +
", regex=" + isRegularExpression() +
", markAll=" + getMarkAll() +
"]";
}
}