###############################################################################
# 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
###############################################################################
browserTitle = Help - {0}
Search=&Search
SearchResults=Search Results
Content=Contents
Links=Links
Bookshelf=Table of Contents
show_all=Show All Topics
Toggle=Toggle Navigation
Synch=Show in Table of Contents
SynchNav=Refresh / Show Current Topic
shortSynch=Sync
Print=Print Page
Close=Close
Nothing_found=Nothing found.
Indexing=Indexing...
complete=complete
GO=GO
pressF1=In the workbench, you can get context-sensitive help (called infopops) for a widget by putting focus on it and pressing F1. If you click one of the infopop's links, it will bring you here, and show you all the links to related topics.
doSearch=To search the documentation, type a query in the Search field. The search results will be shown in this view.
Advanced=Advanced Search
SearchExpression=Search Expression
PotentialHit={0} (potential hit)
expression_label = * = any string, ? = any character, "" = phrase, AND, OR, NOT = boolean operators 
Cancel=Cancel
Select=Select a set of books to be searched:
Toolbar=Toolbar
Tabs=Tabs
Banner=Banner
CannotSync=The current document displayed does not exist in the table of contents.
JavaScript_disabled=This page requires JavaScript.  You need to enable JavaScript in your web browser, restart the browser, and return to this page.
back_tip = Go Back
forward_tip = Go Forward
noTopic=The topic that you have requested is not available. The link may be wrong, or you may not have the corresponding product feature installed. This online help only includes documentation for features that are installed.
IndexingPleaseWait=Please wait while the online information is indexed. This will happen only once.
Bookmarks = Bookmarks
BookmarkPage = Bookmark Document
RemoveBookmark = Delete
RemoveAllBookmarks = Delete All
deleteBookmark = Delete Selected Bookmark
deleteAllBookmarks = Delete All Bookmarks
confirmDeleteAllBookmarks = All bookmarks will be deleted.  Proceed?
addBookmark=There are currently no bookmarks. To add one, press the bookmark icon on the main toolbar while browsing a topic.
Help=Help

searchTooComplex=Search request too complex.
disabledResults=Results from Disabled Capabilities 

# View names
toc=Contents
index=Index
links=Links
search=Search Results
bookmarks=Bookmarks

Views=Navigation Views
noLiveHelp=Active help is not enabled in your installation.
noLiveHelpInInfocenter=You must run help locally to perform "active help" actions.
cookieSaveFailed=Saving search scope failed.  Please reduce search scope definitions.
CookieUtil.tooManyCookiesNeeded=Too may cookies required to store data.

All=All topics
selectAll=Search &all topics
selectWorkingSet=Search only the following &topics
SelectWorkingSet=Select Search Scope
NewWorkingSetButton=&New
EditWorkingSetButton=&Edit
RemoveWorkingSetButton=&Remove
OK=OK
NewWorkingSet=New Search List
EditWorkingSet=Edit Search List
WorkingSetName=List &name
WorkingSetContent=Topics to search
Scope=Search scope
ScopeTooltip=Select Search Scope

#Confirm Show All Topics dialog
confirmShowAllTitle=Confirm
confirmShowAllQuestion=This action will reveal all topics in the table of contents.
confirmShowAllExplanation=When you choose to show all topics in the table of contents, the headings for documentation about any disabled capabilities are also shown in the table of contents and search results.  This documentation may refer to user interface elements that are not visible.  To manually enable capabilities, use the "Capabilities" preference page.<br><br>Proceed?
yes=Yes
no=No
askShowAllQuestion=The topic displayed is not found in the table of contents.<BR>Do you want table of contents to show all topics?
askShowAllExplanation=Table of contents contains topics from enabled capabilities, and the topics you are trying to view does not exist in this set.  The set can be expanded to see all topics.  You can manually show all topics by selecting "Show All Topics" button in the toolbar at anytime.
dontask=Do &not warn me again

# Frame Titles 
ignore=Layout frame: {0}
helpToolbarFrame=Main Help Toolbar
TabsFrame=Selection of Navigation Views
topicView=Topic View
topicViewToolbar=Topic View Toolbar
tocView=Contents View
tocViewToolbar=Contents View Toolbar
linksView=Links View
linksViewToolbar=Links View Toolbar
searchView=Search Results View
searchViewToolbar=Search Results View Toolbar
bookmarksView=Bookmarks View
bookmarksViewToolbar=Bookmarks View Toolbar

# Alt text
bookClosed=Book closed
bookOpen=Book open
topicClosed=Topic closed
topicOpen=Topic open
maximize=Maximize
restore=Restore
expandTopicTitles=Expand topics
collapseTopicTitles=Collapse topics

disabledTopic1 = This topic belongs to a capability that is currently disabled.\n
disabledTopic2 = It may refer to user interface elements that are not visible.\n
disabledTopic3 = To manually enable capabilities, use
disabledTopic4 = Capabilities preference page.

# Titles for Index frames
IndexViewTitle=Index View
IndexTypeinTitle=Index Typein
IndexListTitle=Index List

# Index View text
IndexTypeinInstructions=Type in the word to find:
IndexTypeinButton=Display
