415854 : Filter installed softwares

This patch adds a filter to the installed sofwtare page, similar to the
one present in the plugins page.

Displayed IUs are filtered on IU id, name, provider (depending on the
columns displayed on the page actually).

The StringMatcher class, originally copied from
org.eclipse.ui.internal.misc.StringMatcher into ComboAutoCompleteField was
refactored as an -internal- top level class
org.eclipse.equinox.internal.p2.ui/misc.StringMatcher, for the purpose of
this new feature.

Filtering in action : http://screencast.com/t/qNWw6SpvMM8

Change-Id: I71f8014f46e7321b0df6ce1bf3fd30dab2a37ad6
Signed-off-by: Fred Bricon <fbricon@gmail.com>

5 files changed, 561 insertions, 434 deletions

diff --git a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/ProvUIMessages.java b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/ProvUIMessages.java
index df3f59e59..520dba197 100644
--- a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/ProvUIMessages.java
+++ b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/ProvUIMessages.java
@@ -87,6 +87,7 @@ public class ProvUIMessages extends NLS {
 	public static String ProvisioningOperationRunner_CannotApplyChanges;
 	public static String ProvisioningOperationWizard_Remediation_Operation;
 	public static String ProvisioningOperationWizard_UnexpectedFailureToResolve;
+	public static String InstalledSoftwarePage_Filter_Installed_Software;
 	public static String InstalledSoftwarePage_NoProfile;
 	public static String InstallIUOperationLabel;
 	public static String InstallIUOperationTask;
diff --git a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/dialogs/ComboAutoCompleteField.java b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/dialogs/ComboAutoCompleteField.java
index bfd8b4ac7..cb0d07c84 100644
--- a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/dialogs/ComboAutoCompleteField.java
+++ b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/dialogs/ComboAutoCompleteField.java
@@ -12,7 +12,7 @@
 package org.eclipse.equinox.internal.p2.ui.dialogs;
 
 import java.util.ArrayList;
-import java.util.Vector;
+import org.eclipse.equinox.internal.p2.ui.misc.StringMatcher;
 import org.eclipse.jface.fieldassist.*;
 import org.eclipse.swt.widgets.Combo;
 
@@ -96,436 +96,4 @@ public class ComboAutoCompleteField {
 			}
 		};
 	}
-
-	/**
-	 * A string pattern matcher, suppporting "*" and "?" wildcards.
-	 * Copied from the 1.14 CVS Revision of org.eclipse.ui.internal.misc.StringMatcher
-	 * The only changes made were to fix javadoc warnings, so any future fixes should
-	 * be able to be directly copied over.
-	 */
-	static class StringMatcher {
-		protected String fPattern;
-
-		protected int fLength; // pattern length
-
-		protected boolean fIgnoreWildCards;
-
-		protected boolean fIgnoreCase;
-
-		protected boolean fHasLeadingStar;
-
-		protected boolean fHasTrailingStar;
-
-		protected String fSegments[]; //the given pattern is split into * separated segments
-
-		/* boundary value beyond which we don't need to search in the text */
-		protected int fBound = 0;
-
-		protected static final char fSingleWildCard = '\u0000';
-
-		static class Position {
-			int start; //inclusive
-
-			int end; //exclusive
-
-			public Position(int start, int end) {
-				this.start = start;
-				this.end = end;
-			}
-
-			public int getStart() {
-				return start;
-			}
-
-			public int getEnd() {
-				return end;
-			}
-		}
-
-		/**
-		 * StringMatcher constructor takes in a String object that is a simple 
-		 * pattern which may contain '*' for 0 and many characters and
-		 * '?' for exactly one character.  
-		 *
-		 * Literal '*' and '?' characters must be escaped in the pattern 
-		 * e.g., "\*" means literal "*", etc.
-		 *
-		 * Escaping any other character (including the escape character itself), 
-		 * just results in that character in the pattern.
-		 * e.g., "\a" means "a" and "\\" means "\"
-		 *
-		 * If invoking the StringMatcher with string literals in Java, don't forget
-		 * escape characters are represented by "\\".
-		 *
-		 * @param pattern the pattern to match text against
-		 * @param ignoreCase if true, case is ignored
-		 * @param ignoreWildCards if true, wild cards and their escape sequences are ignored
-		 * 		  (everything is taken literally).
-		 */
-		public StringMatcher(String pattern, boolean ignoreCase, boolean ignoreWildCards) {
-			if (pattern == null) {
-				throw new IllegalArgumentException();
-			}
-			fIgnoreCase = ignoreCase;
-			fIgnoreWildCards = ignoreWildCards;
-			fPattern = pattern;
-			fLength = pattern.length();
-
-			if (fIgnoreWildCards) {
-				parseNoWildCards();
-			} else {
-				parseWildCards();
-			}
-		}
-
-		/**
-		 * Find the first occurrence of the pattern between <code>start</code)(inclusive) 
-		 * and <code>end</code>(exclusive).  
-		 * @param text the String object to search in 
-		 * @param start the starting index of the search range, inclusive
-		 * @param end the ending index of the search range, exclusive
-		 * @return an <code>StringMatcher.Position</code> object that keeps the starting 
-		 * (inclusive) and ending positions (exclusive) of the first occurrence of the 
-		 * pattern in the specified range of the text; return null if not found or subtext
-		 * is empty (start==end). A pair of zeros is returned if pattern is empty string
-		 * Note that for pattern like "*abc*" with leading and trailing stars, position of "abc"
-		 * is returned. For a pattern like"*??*" in text "abcdf", (1,3) is returned
-		 */
-		public StringMatcher.Position find(String text, int start, int end) {
-			if (text == null) {
-				throw new IllegalArgumentException();
-			}
-
-			int tlen = text.length();
-			if (start < 0) {
-				start = 0;
-			}
-			if (end > tlen) {
-				end = tlen;
-			}
-			if (end < 0 || start >= end) {
-				return null;
-			}
-			if (fLength == 0) {
-				return new Position(start, start);
-			}
-			if (fIgnoreWildCards) {
-				int x = posIn(text, start, end);
-				if (x < 0) {
-					return null;
-				}
-				return new Position(x, x + fLength);
-			}
-
-			int segCount = fSegments.length;
-			if (segCount == 0) {
-				return new Position(start, end);
-			}
-
-			int curPos = start;
-			int matchStart = -1;
-			int i;
-			for (i = 0; i < segCount && curPos < end; ++i) {
-				String current = fSegments[i];
-				int nextMatch = regExpPosIn(text, curPos, end, current);
-				if (nextMatch < 0) {
-					return null;
-				}
-				if (i == 0) {
-					matchStart = nextMatch;
-				}
-				curPos = nextMatch + current.length();
-			}
-			if (i < segCount) {
-				return null;
-			}
-			return new Position(matchStart, curPos);
-		}
-
-		/**
-		 * match the given <code>text</code> with the pattern 
-		 * @return true if matched otherwise false
-		 * @param text a String object 
-		 */
-		public boolean match(String text) {
-			if (text == null) {
-				return false;
-			}
-			return match(text, 0, text.length());
-		}
-
-		/**
-		 * Given the starting (inclusive) and the ending (exclusive) positions in the   
-		 * <code>text</code>, determine if the given substring matches with aPattern  
-		 * @return true if the specified portion of the text matches the pattern
-		 * @param text a String object that contains the substring to match 
-		 * @param start marks the starting position (inclusive) of the substring
-		 * @param end marks the ending index (exclusive) of the substring 
-		 */
-		public boolean match(String text, int start, int end) {
-			if (null == text) {
-				throw new IllegalArgumentException();
-			}
-
-			if (start > end) {
-				return false;
-			}
-
-			if (fIgnoreWildCards) {
-				return (end - start == fLength) && fPattern.regionMatches(fIgnoreCase, 0, text, start, fLength);
-			}
-			int segCount = fSegments.length;
-			if (segCount == 0 && (fHasLeadingStar || fHasTrailingStar)) {
-				return true;
-			}
-			if (start == end) {
-				return fLength == 0;
-			}
-			if (fLength == 0) {
-				return start == end;
-			}
-
-			int tlen = text.length();
-			if (start < 0) {
-				start = 0;
-			}
-			if (end > tlen) {
-				end = tlen;
-			}
-
-			int tCurPos = start;
-			int bound = end - fBound;
-			if (bound < 0) {
-				return false;
-			}
-			int i = 0;
-			String current = fSegments[i];
-			int segLength = current.length();
-
-			/* process first segment */
-			if (!fHasLeadingStar) {
-				if (!regExpRegionMatches(text, start, current, 0, segLength)) {
-					return false;
-				} else {
-					++i;
-					tCurPos = tCurPos + segLength;
-				}
-			}
-			if ((fSegments.length == 1) && (!fHasLeadingStar) && (!fHasTrailingStar)) {
-				// only one segment to match, no wildcards specified
-				return tCurPos == end;
-			}
-			/* process middle segments */
-			while (i < segCount) {
-				current = fSegments[i];
-				int currentMatch;
-				int k = current.indexOf(fSingleWildCard);
-				if (k < 0) {
-					currentMatch = textPosIn(text, tCurPos, end, current);
-					if (currentMatch < 0) {
-						return false;
-					}
-				} else {
-					currentMatch = regExpPosIn(text, tCurPos, end, current);
-					if (currentMatch < 0) {
-						return false;
-					}
-				}
-				tCurPos = currentMatch + current.length();
-				i++;
-			}
-
-			/* process final segment */
-			if (!fHasTrailingStar && tCurPos != end) {
-				int clen = current.length();
-				return regExpRegionMatches(text, end - clen, current, 0, clen);
-			}
-			return i == segCount;
-		}
-
-		/**
-		 * This method parses the given pattern into segments seperated by wildcard '*' characters.
-		 * Since wildcards are not being used in this case, the pattern consists of a single segment.
-		 */
-		private void parseNoWildCards() {
-			fSegments = new String[1];
-			fSegments[0] = fPattern;
-			fBound = fLength;
-		}
-
-		/**
-		 * Parses the given pattern into segments seperated by wildcard '*' characters.
-		 */
-		private void parseWildCards() {
-			if (fPattern.startsWith("*")) { //$NON-NLS-1$
-				fHasLeadingStar = true;
-			}
-			if (fPattern.endsWith("*")) {//$NON-NLS-1$
-				/* make sure it's not an escaped wildcard */
-				if (fLength > 1 && fPattern.charAt(fLength - 2) != '\\') {
-					fHasTrailingStar = true;
-				}
-			}
-
-			Vector<String> temp = new Vector<String>();
-
-			int pos = 0;
-			StringBuffer buf = new StringBuffer();
-			while (pos < fLength) {
-				char c = fPattern.charAt(pos++);
-				switch (c) {
-					case '\\' :
-						if (pos >= fLength) {
-							buf.append(c);
-						} else {
-							char next = fPattern.charAt(pos++);
-							/* if it's an escape sequence */
-							if (next == '*' || next == '?' || next == '\\') {
-								buf.append(next);
-							} else {
-								/* not an escape sequence, just insert literally */
-								buf.append(c);
-								buf.append(next);
-							}
-						}
-						break;
-					case '*' :
-						if (buf.length() > 0) {
-							/* new segment */
-							temp.addElement(buf.toString());
-							fBound += buf.length();
-							buf.setLength(0);
-						}
-						break;
-					case '?' :
-						/* append special character representing single match wildcard */
-						buf.append(fSingleWildCard);
-						break;
-					default :
-						buf.append(c);
-				}
-			}
-
-			/* add last buffer to segment list */
-			if (buf.length() > 0) {
-				temp.addElement(buf.toString());
-				fBound += buf.length();
-			}
-
-			fSegments = new String[temp.size()];
-			temp.copyInto(fSegments);
-		}
-
-		/** 
-		 * @param text a string which contains no wildcard
-		 * @param start the starting index in the text for search, inclusive
-		 * @param end the stopping point of search, exclusive
-		 * @return the starting index in the text of the pattern , or -1 if not found 
-		 */
-		protected int posIn(String text, int start, int end) {//no wild card in pattern
-			int max = end - fLength;
-
-			if (!fIgnoreCase) {
-				int i = text.indexOf(fPattern, start);
-				if (i == -1 || i > max) {
-					return -1;
-				}
-				return i;
-			}
-
-			for (int i = start; i <= max; ++i) {
-				if (text.regionMatches(true, i, fPattern, 0, fLength)) {
-					return i;
-				}
-			}
-
-			return -1;
-		}
-
-		/** 
-		 * @param text a simple regular expression that may only contain '?'(s)
-		 * @param start the starting index in the text for search, inclusive
-		 * @param end the stopping point of search, exclusive
-		 * @param p a simple regular expression that may contains '?'
-		 * @return the starting index in the text of the pattern , or -1 if not found 
-		 */
-		protected int regExpPosIn(String text, int start, int end, String p) {
-			int plen = p.length();
-
-			int max = end - plen;
-			for (int i = start; i <= max; ++i) {
-				if (regExpRegionMatches(text, i, p, 0, plen)) {
-					return i;
-				}
-			}
-			return -1;
-		}
-
-		/**
-		 * 
-		 * @return boolean
-		 * @param text a String to match
-		 * @param tStart int that indicates the starting index of match, inclusive
-		 * @param p String,  String, a simple regular expression that may contain '?'
-		 * @param plen length of string
-		 */
-		protected boolean regExpRegionMatches(String text, int tStart, String p, int pStart, int plen) {
-			while (plen-- > 0) {
-				char tchar = text.charAt(tStart++);
-				char pchar = p.charAt(pStart++);
-
-				/* process wild cards */
-				if (!fIgnoreWildCards) {
-					/* skip single wild cards */
-					if (pchar == fSingleWildCard) {
-						continue;
-					}
-				}
-				if (pchar == tchar) {
-					continue;
-				}
-				if (fIgnoreCase) {
-					if (Character.toUpperCase(tchar) == Character.toUpperCase(pchar)) {
-						continue;
-					}
-					// comparing after converting to upper case doesn't handle all cases;
-					// also compare after converting to lower case
-					if (Character.toLowerCase(tchar) == Character.toLowerCase(pchar)) {
-						continue;
-					}
-				}
-				return false;
-			}
-			return true;
-		}
-
-		/** 
-		 * @param text the string to match
-		 * @param start the starting index in the text for search, inclusive
-		 * @param end the stopping point of search, exclusive
-		 * @param p a pattern string that has no wildcard
-		 * @return the starting index in the text of the pattern , or -1 if not found 
-		 */
-		protected int textPosIn(String text, int start, int end, String p) {
-
-			int plen = p.length();
-			int max = end - plen;
-
-			if (!fIgnoreCase) {
-				int i = text.indexOf(p, start);
-				if (i == -1 || i > max) {
-					return -1;
-				}
-				return i;
-			}
-
-			for (int i = start; i <= max; ++i) {
-				if (text.regionMatches(true, i, p, 0, plen)) {
-					return i;
-				}
-			}
-
-			return -1;
-		}
-	}
 }
\ No newline at end of file
diff --git a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/messages.properties b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/messages.properties
index 36a7880e9..a703fc53d 100644
--- a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/messages.properties
+++ b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/messages.properties
@@ -16,6 +16,7 @@ ProfileSnapshots_Label=Installation History
 ProvisioningOperationRunner_CannotApplyChanges=The changes could not be applied while the application is running.  You must restart the application for the changes to take effect.
 ProvisioningOperationWizard_Remediation_Operation=Compute remediation operation
 ProvisioningOperationWizard_UnexpectedFailureToResolve=Unexpected error
+InstalledSoftwarePage_Filter_Installed_Software=type filter text
 InstalledSoftwarePage_NoProfile=This installation has not been configured for showing the installed software.  See the error log for details.
 InstallIUOperationLabel=Install
 InstallIUOperationTask=Software installation in progress...
diff --git a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/misc/StringMatcher.java b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/misc/StringMatcher.java
new file mode 100644
index 000000000..d0ca81bcc
--- /dev/null
+++ b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/internal/p2/ui/misc/StringMatcher.java
@@ -0,0 +1,447 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2006 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.equinox.internal.p2.ui.misc;
+
+import java.util.Vector;
+
+/**
+ * A string pattern matcher, suppporting "*" and "?" wildcards.
+ * Copied from the 1.14 CVS Revision of org.eclipse.ui.internal.misc.StringMatcher
+ * The only changes made were to fix javadoc warnings, so any future fixes should
+ * be able to be directly copied over.
+ * 
+ * @since 2.3
+ */
+public class StringMatcher {
+	protected String fPattern;
+
+	protected int fLength; // pattern length
+
+	protected boolean fIgnoreWildCards;
+
+	protected boolean fIgnoreCase;
+
+	protected boolean fHasLeadingStar;
+
+	protected boolean fHasTrailingStar;
+
+	protected String fSegments[]; //the given pattern is split into * separated segments
+
+	/* boundary value beyond which we don't need to search in the text */
+	protected int fBound = 0;
+
+	protected static final char fSingleWildCard = '\u0000';
+
+	static class Position {
+		int start; //inclusive
+
+		int end; //exclusive
+
+		public Position(int start, int end) {
+			this.start = start;
+			this.end = end;
+		}
+
+		public int getStart() {
+			return start;
+		}
+
+		public int getEnd() {
+			return end;
+		}
+	}
+
+	/**
+	 * StringMatcher constructor takes in a String object that is a simple 
+	 * pattern which may contain '*' for 0 and many characters and
+	 * '?' for exactly one character.  
+	 *
+	 * Literal '*' and '?' characters must be escaped in the pattern 
+	 * e.g., "\*" means literal "*", etc.
+	 *
+	 * Escaping any other character (including the escape character itself), 
+	 * just results in that character in the pattern.
+	 * e.g., "\a" means "a" and "\\" means "\"
+	 *
+	 * If invoking the StringMatcher with string literals in Java, don't forget
+	 * escape characters are represented by "\\".
+	 *
+	 * @param pattern the pattern to match text against
+	 * @param ignoreCase if true, case is ignored
+	 * @param ignoreWildCards if true, wild cards and their escape sequences are ignored
+	 * 		  (everything is taken literally).
+	 */
+	public StringMatcher(String pattern, boolean ignoreCase, boolean ignoreWildCards) {
+		if (pattern == null) {
+			throw new IllegalArgumentException();
+		}
+		fIgnoreCase = ignoreCase;
+		fIgnoreWildCards = ignoreWildCards;
+		fPattern = pattern;
+		fLength = pattern.length();
+
+		if (fIgnoreWildCards) {
+			parseNoWildCards();
+		} else {
+			parseWildCards();
+		}
+	}
+
+	/**
+	 * Find the first occurrence of the pattern between <code>start</code)(inclusive) 
+	 * and <code>end</code>(exclusive).  
+	 * @param text the String object to search in 
+	 * @param start the starting index of the search range, inclusive
+	 * @param end the ending index of the search range, exclusive
+	 * @return an <code>StringMatcher.Position</code> object that keeps the starting 
+	 * (inclusive) and ending positions (exclusive) of the first occurrence of the 
+	 * pattern in the specified range of the text; return null if not found or subtext
+	 * is empty (start==end). A pair of zeros is returned if pattern is empty string
+	 * Note that for pattern like "*abc*" with leading and trailing stars, position of "abc"
+	 * is returned. For a pattern like"*??*" in text "abcdf", (1,3) is returned
+	 */
+	public StringMatcher.Position find(String text, int start, int end) {
+		if (text == null) {
+			throw new IllegalArgumentException();
+		}
+
+		int tlen = text.length();
+		if (start < 0) {
+			start = 0;
+		}
+		if (end > tlen) {
+			end = tlen;
+		}
+		if (end < 0 || start >= end) {
+			return null;
+		}
+		if (fLength == 0) {
+			return new Position(start, start);
+		}
+		if (fIgnoreWildCards) {
+			int x = posIn(text, start, end);
+			if (x < 0) {
+				return null;
+			}
+			return new Position(x, x + fLength);
+		}
+
+		int segCount = fSegments.length;
+		if (segCount == 0) {
+			return new Position(start, end);
+		}
+
+		int curPos = start;
+		int matchStart = -1;
+		int i;
+		for (i = 0; i < segCount && curPos < end; ++i) {
+			String current = fSegments[i];
+			int nextMatch = regExpPosIn(text, curPos, end, current);
+			if (nextMatch < 0) {
+				return null;
+			}
+			if (i == 0) {
+				matchStart = nextMatch;
+			}
+			curPos = nextMatch + current.length();
+		}
+		if (i < segCount) {
+			return null;
+		}
+		return new Position(matchStart, curPos);
+	}
+
+	/**
+	 * match the given <code>text</code> with the pattern 
+	 * @return true if matched otherwise false
+	 * @param text a String object 
+	 */
+	public boolean match(String text) {
+		if (text == null) {
+			return false;
+		}
+		return match(text, 0, text.length());
+	}
+
+	/**
+	 * Given the starting (inclusive) and the ending (exclusive) positions in the   
+	 * <code>text</code>, determine if the given substring matches with aPattern  
+	 * @return true if the specified portion of the text matches the pattern
+	 * @param text a String object that contains the substring to match 
+	 * @param start marks the starting position (inclusive) of the substring
+	 * @param end marks the ending index (exclusive) of the substring 
+	 */
+	public boolean match(String text, int start, int end) {
+		if (null == text) {
+			throw new IllegalArgumentException();
+		}
+
+		if (start > end) {
+			return false;
+		}
+
+		if (fIgnoreWildCards) {
+			return (end - start == fLength) && fPattern.regionMatches(fIgnoreCase, 0, text, start, fLength);
+		}
+		int segCount = fSegments.length;
+		if (segCount == 0 && (fHasLeadingStar || fHasTrailingStar)) {
+			return true;
+		}
+		if (start == end) {
+			return fLength == 0;
+		}
+		if (fLength == 0) {
+			return start == end;
+		}
+
+		int tlen = text.length();
+		if (start < 0) {
+			start = 0;
+		}
+		if (end > tlen) {
+			end = tlen;
+		}
+
+		int tCurPos = start;
+		int bound = end - fBound;
+		if (bound < 0) {
+			return false;
+		}
+		int i = 0;
+		String current = fSegments[i];
+		int segLength = current.length();
+
+		/* process first segment */
+		if (!fHasLeadingStar) {
+			if (!regExpRegionMatches(text, start, current, 0, segLength)) {
+				return false;
+			} else {
+				++i;
+				tCurPos = tCurPos + segLength;
+			}
+		}
+		if ((fSegments.length == 1) && (!fHasLeadingStar) && (!fHasTrailingStar)) {
+			// only one segment to match, no wildcards specified
+			return tCurPos == end;
+		}
+		/* process middle segments */
+		while (i < segCount) {
+			current = fSegments[i];
+			int currentMatch;
+			int k = current.indexOf(fSingleWildCard);
+			if (k < 0) {
+				currentMatch = textPosIn(text, tCurPos, end, current);
+				if (currentMatch < 0) {
+					return false;
+				}
+			} else {
+				currentMatch = regExpPosIn(text, tCurPos, end, current);
+				if (currentMatch < 0) {
+					return false;
+				}
+			}
+			tCurPos = currentMatch + current.length();
+			i++;
+		}
+
+		/* process final segment */
+		if (!fHasTrailingStar && tCurPos != end) {
+			int clen = current.length();
+			return regExpRegionMatches(text, end - clen, current, 0, clen);
+		}
+		return i == segCount;
+	}
+
+	/**
+	 * This method parses the given pattern into segments seperated by wildcard '*' characters.
+	 * Since wildcards are not being used in this case, the pattern consists of a single segment.
+	 */
+	private void parseNoWildCards() {
+		fSegments = new String[1];
+		fSegments[0] = fPattern;
+		fBound = fLength;
+	}
+
+	/**
+	 * Parses the given pattern into segments seperated by wildcard '*' characters.
+	 */
+	private void parseWildCards() {
+		if (fPattern.startsWith("*")) { //$NON-NLS-1$
+			fHasLeadingStar = true;
+		}
+		if (fPattern.endsWith("*")) {//$NON-NLS-1$
+			/* make sure it's not an escaped wildcard */
+			if (fLength > 1 && fPattern.charAt(fLength - 2) != '\\') {
+				fHasTrailingStar = true;
+			}
+		}
+
+		Vector<String> temp = new Vector<String>();
+
+		int pos = 0;
+		StringBuffer buf = new StringBuffer();
+		while (pos < fLength) {
+			char c = fPattern.charAt(pos++);
+			switch (c) {
+				case '\\' :
+					if (pos >= fLength) {
+						buf.append(c);
+					} else {
+						char next = fPattern.charAt(pos++);
+						/* if it's an escape sequence */
+						if (next == '*' || next == '?' || next == '\\') {
+							buf.append(next);
+						} else {
+							/* not an escape sequence, just insert literally */
+							buf.append(c);
+							buf.append(next);
+						}
+					}
+					break;
+				case '*' :
+					if (buf.length() > 0) {
+						/* new segment */
+						temp.addElement(buf.toString());
+						fBound += buf.length();
+						buf.setLength(0);
+					}
+					break;
+				case '?' :
+					/* append special character representing single match wildcard */
+					buf.append(fSingleWildCard);
+					break;
+				default :
+					buf.append(c);
+			}
+		}
+
+		/* add last buffer to segment list */
+		if (buf.length() > 0) {
+			temp.addElement(buf.toString());
+			fBound += buf.length();
+		}
+
+		fSegments = new String[temp.size()];
+		temp.copyInto(fSegments);
+	}
+
+	/** 
+	 * @param text a string which contains no wildcard
+	 * @param start the starting index in the text for search, inclusive
+	 * @param end the stopping point of search, exclusive
+	 * @return the starting index in the text of the pattern , or -1 if not found 
+	 */
+	protected int posIn(String text, int start, int end) {//no wild card in pattern
+		int max = end - fLength;
+
+		if (!fIgnoreCase) {
+			int i = text.indexOf(fPattern, start);
+			if (i == -1 || i > max) {
+				return -1;
+			}
+			return i;
+		}
+
+		for (int i = start; i <= max; ++i) {
+			if (text.regionMatches(true, i, fPattern, 0, fLength)) {
+				return i;
+			}
+		}
+
+		return -1;
+	}
+
+	/** 
+	 * @param text a simple regular expression that may only contain '?'(s)
+	 * @param start the starting index in the text for search, inclusive
+	 * @param end the stopping point of search, exclusive
+	 * @param p a simple regular expression that may contains '?'
+	 * @return the starting index in the text of the pattern , or -1 if not found 
+	 */
+	protected int regExpPosIn(String text, int start, int end, String p) {
+		int plen = p.length();
+
+		int max = end - plen;
+		for (int i = start; i <= max; ++i) {
+			if (regExpRegionMatches(text, i, p, 0, plen)) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	/**
+	 * 
+	 * @return boolean
+	 * @param text a String to match
+	 * @param tStart int that indicates the starting index of match, inclusive
+	 * @param p String,  String, a simple regular expression that may contain '?'
+	 * @param plen length of string
+	 */
+	protected boolean regExpRegionMatches(String text, int tStart, String p, int pStart, int plen) {
+		while (plen-- > 0) {
+			char tchar = text.charAt(tStart++);
+			char pchar = p.charAt(pStart++);
+
+			/* process wild cards */
+			if (!fIgnoreWildCards) {
+				/* skip single wild cards */
+				if (pchar == fSingleWildCard) {
+					continue;
+				}
+			}
+			if (pchar == tchar) {
+				continue;
+			}
+			if (fIgnoreCase) {
+				if (Character.toUpperCase(tchar) == Character.toUpperCase(pchar)) {
+					continue;
+				}
+				// comparing after converting to upper case doesn't handle all cases;
+				// also compare after converting to lower case
+				if (Character.toLowerCase(tchar) == Character.toLowerCase(pchar)) {
+					continue;
+				}
+			}
+			return false;
+		}
+		return true;
+	}
+
+	/** 
+	 * @param text the string to match
+	 * @param start the starting index in the text for search, inclusive
+	 * @param end the stopping point of search, exclusive
+	 * @param p a pattern string that has no wildcard
+	 * @return the starting index in the text of the pattern , or -1 if not found 
+	 */
+	protected int textPosIn(String text, int start, int end, String p) {
+
+		int plen = p.length();
+		int max = end - plen;
+
+		if (!fIgnoreCase) {
+			int i = text.indexOf(p, start);
+			if (i == -1 || i > max) {
+				return -1;
+			}
+			return i;
+		}
+
+		for (int i = start; i <= max; ++i) {
+			if (text.regionMatches(true, i, p, 0, plen)) {
+				return i;
+			}
+		}
+
+		return -1;
+	}
+}
\ No newline at end of file
diff --git a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/p2/ui/InstalledSoftwarePage.java b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/p2/ui/InstalledSoftwarePage.java
index c8c39034f..0f7d105c5 100644
--- a/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/p2/ui/InstalledSoftwarePage.java
+++ b/bundles/org.eclipse.equinox.p2.ui/src/org/eclipse/equinox/p2/ui/InstalledSoftwarePage.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- *  Copyright (c) 2008, 2011 IBM Corporation and others.
+ *  Copyright (c) 2008, 2013 IBM Corporation and others.
  *  All rights reserved. This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License v1.0
  *  which accompanies this distribution, and is available at
@@ -8,6 +8,7 @@
  *  Contributors:
  *     IBM Corporation - initial API and implementation
  *     Sonatype, Inc. - ongoing development
+ *     Red Hat,Inc. - filter installed softwares
  *******************************************************************************/
 
 package org.eclipse.equinox.p2.ui;
@@ -16,17 +17,22 @@ import org.eclipse.core.runtime.IStatus;
 import org.eclipse.equinox.internal.p2.ui.*;
 import org.eclipse.equinox.internal.p2.ui.actions.*;
 import org.eclipse.equinox.internal.p2.ui.dialogs.*;
+import org.eclipse.equinox.internal.p2.ui.misc.StringMatcher;
+import org.eclipse.equinox.internal.p2.ui.model.InstalledIUElement;
 import org.eclipse.equinox.internal.p2.ui.viewers.IUColumnConfig;
 import org.eclipse.equinox.internal.p2.ui.viewers.IUDetailsLabelProvider;
 import org.eclipse.equinox.p2.metadata.IInstallableUnit;
 import org.eclipse.jface.action.Action;
 import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.layout.GridDataFactory;
 import org.eclipse.jface.resource.JFaceResources;
 import org.eclipse.jface.viewers.*;
 import org.eclipse.jface.window.SameShellProvider;
 import org.eclipse.jface.window.Window;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.dnd.*;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.*;
@@ -60,6 +66,7 @@ public class InstalledSoftwarePage extends InstallationPage implements ICopyable
 	String profileId;
 	Button updateButton, uninstallButton, propertiesButton;
 	ProvisioningUI ui;
+	private Text filterText;
 
 	/* (non-Javadoc)
 	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
@@ -90,6 +97,12 @@ public class InstalledSoftwarePage extends InstallationPage implements ICopyable
 		layout.marginHeight = 0;
 		composite.setLayout(layout);
 
+		//Let users filter installed softwares
+		filterText = new Text(composite, SWT.BORDER | SWT.SEARCH | SWT.ICON_CANCEL);
+		filterText.setLayoutData(GridDataFactory.fillDefaults().create());
+		filterText.setMessage(ProvUIMessages.InstalledSoftwarePage_Filter_Installed_Software);
+		filterText.setFocus();//Steal focus, consistent with org.eclipse.ui.internal.about.AboutPluginsPage
+
 		// Table of installed IU's
 		installedIUGroup = new InstalledIUGroup(getProvisioningUI(), composite, JFaceResources.getDialogFont(), profileId, getColumnConfig());
 		// we hook selection listeners on the viewer in createPageButtons because we
@@ -181,6 +194,17 @@ public class InstalledSoftwarePage extends InstallationPage implements ICopyable
 
 		});
 
+		final IUPatternFilter searchFilter = new IUPatternFilter(getColumnConfig());
+		filterText.addModifyListener(new ModifyListener() {
+			public void modifyText(ModifyEvent e) {
+				if (filterText != null && !filterText.isDisposed()) {
+					searchFilter.setPattern(filterText.getText());
+					installedIUGroup.getStructuredViewer().refresh();
+				}
+			}
+		});
+		installedIUGroup.getStructuredViewer().addFilter(searchFilter);
+
 		updateEnablement();
 	}
 
@@ -270,4 +294,90 @@ public class InstalledSoftwarePage extends InstallationPage implements ICopyable
 		ui = value;
 	}
 
+	/**
+	 * Filters {@link InstalledIUElement}s from a viewer using a String pattern. 
+	 * Filtering is dependent on a given array of {@link IUColumnConfig}s :
+	 * <ul>
+	 * <li>if {@link IUColumnConfig.COLUMN_ID} is present, filters on the Installable Unit's id;</li>
+	 * <li>if {@link IUColumnConfig.COLUMN_NAME} is present, filters on the Installable Unit's  name;</li>
+	 * <li>if {@link IUColumnConfig.COLUMN_PROVIDER} is present, filters on the Installable Unit's provider;</li>
+	 * </ul>   
+	 * 
+	 * @since 2.3
+	 */
+	class IUPatternFilter extends ViewerFilter {
+
+		private StringMatcher matcher;
+
+		private boolean filterOnId;
+
+		private boolean filterOnName;
+
+		private boolean filterOnProvider;
+
+		public IUPatternFilter() {
+			this(null);
+		}
+
+		public IUPatternFilter(IUColumnConfig[] columnConfig) {
+			if (columnConfig == null) {
+				columnConfig = ProvUI.getIUColumnConfig();
+			}
+			for (IUColumnConfig colConfig : columnConfig) {
+				switch (colConfig.getColumnType()) {
+					case IUColumnConfig.COLUMN_ID :
+						filterOnId = true;
+						break;
+					case IUColumnConfig.COLUMN_NAME :
+						filterOnName = true;
+						break;
+					case IUColumnConfig.COLUMN_PROVIDER :
+						filterOnProvider = true;
+						break;
+					default :
+						break;
+				}
+				if (filterOnId && filterOnName && filterOnProvider) {
+					break;
+				}
+			}
+		}
+
+		public void setPattern(String searchPattern) {
+			if (searchPattern == null || searchPattern.length() == 0) {
+				this.matcher = null;
+			} else {
+				String pattern = "*" + searchPattern + "*"; //$NON-NLS-1$//$NON-NLS-2$
+				this.matcher = new StringMatcher(pattern, true, false);
+			}
+		}
+
+		@Override
+		public boolean select(Viewer viewer, Object parentElement, Object element) {
+			if (matcher == null || !(filterOnName || filterOnId || filterOnProvider)) {
+				return true;
+			}
+
+			if (element instanceof InstalledIUElement) {
+				InstalledIUElement data = (InstalledIUElement) element;
+				IInstallableUnit iu = data.getIU();
+				boolean match = false;
+				if (iu != null) {
+					if (filterOnName) {
+						String name = iu.getProperty(IInstallableUnit.PROP_NAME, null);
+						match = matcher.match(name);
+					}
+					if (!match && filterOnId) {
+						match = matcher.match(iu.getId());
+					}
+					if (!match && filterOnProvider) {
+						String provider = iu.getProperty(IInstallableUnit.PROP_PROVIDER, null);
+						match = matcher.match(provider);
+					}
+				}
+				return match;
+			}
+			return true;
+		}
+	}
 }