###############################################################################
# Copyright (c) 2000, 2005 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
###############################################################################
pluginName=Eclipse Project SDK
providerName=Eclipse.org

activity.java=Java Development
activity.java.desc=Develop Java applications.
activity.plugin=Plug-in Development
activity.plugin.desc=Develop plug-ins, fragments, and features for Eclipse.

activity.team.cvs=CVS Support
activity.team.cvs.desc=Use the Concurrent Versions System (CVS) to manage resources.
activity.team=Core Team Support
activity.team.desc=Share projects using configuration management systems.

activity.cat.development=Development
activity.cat.development.desc=Use the Eclipse SDK to develop applications.
activity.cat.team=Team
activity.cat.team.desc=Use configuration management systems to manage resources.

PreferencePages.Capabilities = Capabilities
PreferencePages.Capabilities.activityName = &Capabilities
PreferencePages.Capabilities.categoryName = &Capabilities
PreferencePages.Capabilities.activityPromptButton = &Prompt when enabling capabilities
PreferencePages.Capabilities.activityPromptButtonTooltip = Prompt when a feature is first used that requires enablement of capabilities
PreferencePages.Capabilities.captionMessage = Capabilities allow you to enable or disable various product components.  These capabilities are grouped according to a set of predefined categories.

helpActivitySupport.showAllMessage = 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?
helpActivitySupport.documentMessage = This topic belongs to a capability that \
is currently disabled. It may refer to user interface elements that are \
not visible.<br><br>\
To manually enable capabilities, use\
&nbsp;<a href='ACTIVITY_EDITOR'>Capabilities preference page.</a>

TriggerPointAdvisor.proceedMulti = Enable the selected capabilities?
TriggerPointAdvisor.proceedSingle = Enable the required capability?
TriggerPointAdvisor.dontAsk = &Always enable capabilities and don't ask me again
TriggerPointAdvisor.noDetails = Select a capability to view its description.

search.Google.label = Google
search.Google.desc = Performs a Google web search

search.Eclipse.label = Eclipse.org 
search.Eclipse.desc = Searches mailing lists, news groups, articles and other documents on Eclipse.org

