<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html lang="en">
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>File Menu actions</title>
<link rel="stylesheet" type="text/css" href="../help.css">
</head>
<body>
	<div role="main">
		<h1>File Menu actions</h1>
		<table class="menu" border="1" cellspacing="0">
			<thead>
				<tr>
					<th id="name">Name</th>
					<th id="function">Function</th>
					<th id="keyboard">Keyboard Shortcut</th>
				</tr>
			</thead>
			<tbody>
				<tr>
					<td class="menu_name" headers="name">New (submenu)</td>
					<td headers="function">Creates a new project, folder, or file</td>
					<td headers="keyboard">Alt+Shift+N</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Open File...</td>
					<td headers="function">Opens an existing file</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Close</td>
					<td headers="function">Closes the current editor (If the
						editor contains unsaved data, a save request dialog is shown.)</td>
					<td headers="keyboard">Ctrl+W</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Close All</td>
					<td headers="function">Closes all editors (If any editors
						contain unsaved data, save request dialogs will be shown for
						them.)</td>
					<td headers="keyboard">Ctrl+Shift+W</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Save</td>
					<td headers="function">Saves the content of the current editor
						(Disabled if the editor does not contain unsaved changes.)</td>
					<td headers="keyboard">Ctrl+S</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Save As...</td>
					<td headers="function">Saves the content of the current editor
						under a new name</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Save All</td>
					<td headers="function">Saves the content of all open editor
						windows (Disabled if no editor contains unsaved changes.)</td>
					<td headers="keyboard">Ctrl+Shift+S</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Revert</td>
					<td headers="function">Reverts the content of the current
						editor back to its most recently saved state (Disabled if the
						editor does not contain unsaved changes.)</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Move...</td>
					<td headers="function">Moves a resource</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Rename...</td>
					<td headers="function">Renames a resource</td>
					<td headers="keyboard">F2</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Refresh</td>
					<td headers="function">Refreshes the selected element against
						the local file system (If nothing is selected, all open projects
						are refreshed.)</td>
					<td headers="keyboard">F5</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Convert Line Delimiters
						to (submenu)</td>
					<td headers="function">Changes the line delimiters of the
						current editor to Windows (\r\n), or UNIX (\n) format</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Print...</td>
					<td headers="function">Prints the content of the current
						editor (Enabled when an editor has the focus.)</td>
					<td headers="keyboard">Ctrl+P</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Switch workspace
						(submenu)</td>
					<td headers="function">Changes the active workspace (The
						submenu contains a list of recently used workspaces, and <strong>Other...</strong>,
						which brings up a workspace selection dialog)
					</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Restart</td>
					<td headers="function">Relaunches Eclipse</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Import...</td>
					<td headers="function">Opens the <strong>Import</strong>
						dialog, which allows the selection of an Import wizard
					</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Export</td>
					<td headers="function">Opens the <strong>Export</strong>
						dialog, which allows the selection of an Export wizard
					</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Properties</td>
					<td headers="function">Opens the property page for the
						selected element</td>
					<td headers="keyboard">Alt+Enter</td>
				</tr>
				<tr>
					<td class="menu_name" headers="name">Exit</td>
					<td headers="function">Exits Eclipse</td>
					<td headers="keyboard">&nbsp;</td>
				</tr>
			</tbody>
		</table>
		<p>
			<img alt="IBM Copyright Statement" src="../images/ng00_04a.gif">
		</p>
	</div>
</body>
</html>