<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">

<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<link rel="stylesheet" type="text/css" href="../../help.css">
<title>Search for text and files on remote servers</title>

</head>

<body id="tmanagesearch">

<h1 class="topictitle1">Search for text and files on remote servers</h1>

<p>You can search for text strings and files on any remote server
or file system, including Linux, UNIX, and Windows systems.</p>
<p>There are three main ways you can search for files and text strings
on remote servers, depending on your goal:
<ul>
<li>Search for text strings within a file</li>
<li>Search for text strings and/or files within a folder</li>
<li>Search for text strings, files, and/or folders within a remote file system</li>
</ul>
To search for files, text strings, and folders:
<ol>
<li>In the Remote Systems view, expand your Linux, UNIX, or Windows
connection until you reach the folder, file, or file system that you want
to search. Select the containing item by clicking on the item.</li>
<li>Right-click and select <strong>Search</strong>. Or, click <strong>Search &gt; Remote</strong> from
the workbench menu. Or, for the keyboard shortcut, enter CTRL+H. All of these
actions will invoke the Search window. </li>
<li>In the Remote Search window, click the Remote Search tab if it is not
already in focus. You can now search for text strings, files, and/or folders,
with the option to use powerful Regular Expressions, in addition normal and
variable expressions, such as a*b. See <a href="http://help.eclipse.org/ganymede/topic/org.eclipse.rse.doc.user/ref/rsearch.html" shape="rect">
the RSE help on Using
search parameters with special characters</a> for more information. Regular
Expressions might be most familiar to Linux and Unix users.

<ul>
<li>To search for strings, in the <strong>Search string</strong> field, enter the string
that you want to search for, whether it be from a file, a folder, or an entire
file system. Select the <strong>Case sensitive</strong> or <strong>Regular expression</strong> check
boxes if they apply. Leave this field as an asterisk (*) if you do not want
to search for strings. You can use commas to specify more than one type of
string to search for. For example, you could enter "*.c, *.java, b?a.txt,
" and so on.</li>
<li>To search for files, in the <strong>File name patterns</strong> field, enter the
name of the file you are looking for. Check the <strong>Regular expression</strong> check
box if this option applies. Leave this field as an asterisk (*) if you do
not want to search for files. You can use commas to specify more than one
type of folder to search for. You can also click <strong>Browse</strong> to select file
extensions to search for.</li>
</ul>
<strong>Note:</strong> <br>
You cannot edit the contents of the <strong>Folder</strong> field; however,
you can click the <strong>Browse</strong> button to browse to and specify another folder.
If the <strong>Folder</strong> field is empty, you need to browse to a particular folder
before you can launch the search.

</li>
<li>Click <strong>Search</strong>.</li>
</ol>
The matching strings and/or files display in the Remote Search view.
The view updates itself as more matches are found and you can click the <strong>Stop</strong> button
if you want to stop the search process. The view shows the strings and/or
files that you searched for, with the matches listed beneath in a tree-view
structure. For example, if you searched the file "README.txt" for the following
string, "*bin*", then the Remote Search results view might look like this:
<p><br clear="none"></br><img alt="" src="../../images/rse_search.gif"></img><br clear="none"></br></p>
<div class="p">To manipulate the set
of search results:
<ul>
	<li>Right-click the parent items of the tree, in this example, "README.txt",
	and you can select any of the regular Remote Systems options, for example, <strong>Open
	With</strong>, <strong>Rename</strong>, <strong>Properties</strong>, and so on.</li>
	<li>Right-click any line beneath the parent search item in the tree, in this
	example, "bin/rmid and jre/bin/rmid":
		<ul>
		<li>Select <strong>Copy</strong> to copy the path as you see it to your clipboard.</li>
		<li>Select <strong>Go to</strong> to open the file in an editor, which highlights the matching text. You can double-click on any line to perform the same action.</li>
		</ul>
	</li>
</ul>
</div>

</body>
</html>