<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.0"?>
<plugin>
   <extension-point id="classPatternProvider" name="%classPatternProvider.name" schema="schema/classPatternProvider.exsd"/>

	<extension point="org.eclipse.ui.editors">
		<editor
			name="%JSP_Source_Page_Editor.name"
			icon="$nl$/icons//full/obj16/sourceEditor.gif"
			extensions="jsp, jsf, jspf, jspx, tag, tagx, tagf"
			contributorClass="org.eclipse.jst.jsp.ui.internal.editor.ActionContributorJSP"
			class="org.eclipse.wst.sse.ui.StructuredTextEditor"
			symbolicFontName="org.eclipse.wst.sse.ui.textfont"
			id="org.eclipse.jst.jsp.core.jspsource.source">
			<contentTypeBinding
				contentTypeId="org.eclipse.jst.jsp.core.jspsource" />
		</editor>
		<editor
			name="%CSS_JSP_Source_Page_Editor.name"
			icon="$nl$/icons//full/obj16/sourceEditor.gif"
			contributorClass="org.eclipse.jst.jsp.ui.internal.editor.ActionContributorJSP"
			class="org.eclipse.wst.sse.ui.StructuredTextEditor"
			symbolicFontName="org.eclipse.wst.sse.ui.textfont"
			id="org.eclipse.jst.jsp.core.cssjspsource.source">
			<contentTypeBinding
				contentTypeId="org.eclipse.jst.jsp.core.cssjspsource" />
			<contentTypeBinding
				contentTypeId="org.eclipse.jst.jsp.core.cssjspfragmentsource" />
		</editor>
	</extension>

	<extension point="org.eclipse.wst.sse.ui.editorConfiguration">
		<sourceViewerConfiguration
			class="org.eclipse.jst.jsp.ui.StructuredTextViewerConfigurationJSP"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<contentOutlineConfiguration
			class="org.eclipse.jst.jsp.ui.views.contentoutline.JSPContentOutlineConfiguration"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<quickOutlineConfiguration
			class="org.eclipse.wst.xml.ui.internal.quickoutline.XMLQuickOutlineConfiguration"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<propertySheetConfiguration
			class="org.eclipse.wst.xml.ui.views.properties.XMLPropertySheetConfiguration"
			target="org.eclipse.jst.jsp.core.jspsource" />
  		<documentationTextHover
        	class="org.eclipse.jst.jsp.ui.internal.taginfo.JSPTagInfoHoverProcessor"
        	target="org.eclipse.jst.jsp.DEFAULT_JSP, org.eclipse.jst.jsp.JSP_DIRECTIVE">
  		</documentationTextHover>
  		<documentationTextHover
        	class="org.eclipse.jst.jsp.ui.internal.taginfo.JSPJavaJavadocHoverProcessor"
        	target="org.eclipse.jst.jsp.SCRIPT.JAVA">
  		</documentationTextHover>
		<provisionalConfiguration
			type="sourceeditingtexttools"
			class="org.eclipse.jst.jsp.ui.internal.editor.JSPSourceEditingTextTools"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<provisionalConfiguration
			type="characterpairmatcher"
			class="org.eclipse.jst.jsp.ui.internal.text.JSPDocumentRegionEdgeMatcher"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<provisionalConfiguration
			type="foldingstrategy"
			class="org.eclipse.wst.xml.ui.internal.projection.XMLFoldingStrategy"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<provisionalDefinition
			type="preferencepages"
			value="org.eclipse.jst.jsp.ui.preferences.jsp, org.eclipse.wst.sse.ui.preferences.jsp.source, org.eclipse.wst.sse.ui.preferences.jsp.templates, org.eclipse.wst.sse.ui.preferences.jsp.styles,,org.eclipse.jst.jsp.ui.preferences.validation, org.eclipse.wst.sse.ui.preferences.jsp.contentassist"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<provisionalDefinition
			type="showintarget"
			value="org.eclipse.jdt.ui.PackageExplorer"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<provisionalDefinition
			type="spellingregions"
			value="XML_COMMENT_TEXT, JSP_COMMENT_TEXT, XML_CONTENT, HTML_CONTENT"
			target="org.eclipse.jst.jsp.core.jspsource" />
		<provisionalDefinition
			type="activecontexts"
			value="org.eclipse.jst.jsp.core.jspsource, org.eclipse.jst.jsp.ui.structured.text.editor.jsp.scope, org.eclipse.wst.html.core.htmlsource, org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.selection, org.eclipse.wst.sse.comments"
        	target="org.eclipse.jst.jsp.core.jspsource" />

		<contentOutlineConfiguration
			class="org.eclipse.jst.jsp.ui.internal.views.contentoutline.TLDContentOutlineConfiguration"
			target="org.eclipse.jst.jsp.core.tldsource" />
		<documentationTextHover
        	class="org.eclipse.jst.jsp.ui.internal.taginfo.XMLJavadocHoverProcessor"
        	target="org.eclipse.wst.xml.XML_DEFAULT"/>
	</extension>

	<!--======================================================================================-->
	<!-- source validation for JSP															  -->
	<!--======================================================================================-->
	<extension point="org.eclipse.wst.sse.ui.sourcevalidation">
		<validator
			scope="total"
			class="org.eclipse.jst.jsp.core.internal.validation.JSPJavaValidator"
			id="org.eclipse.jst.jsp.jspsourcevalidator">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource">
				<partitionType id="org.eclipse.jst.jsp.DEFAULT_JSP">
				</partitionType>
				<partitionType id="org.eclipse.jst.jsp.SCRIPT.JAVA">
				</partitionType>
				<partitionType id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
				</partitionType>
			</contentTypeIdentifier>
		</validator>
	</extension>
	<!--======================================================================================-->
	<!-- source (as you type) validation for JSP EL					   						  -->
	<!--======================================================================================-->
	<extension point="org.eclipse.wst.sse.ui.sourcevalidation">
		<validator
			scope="total"
			class="org.eclipse.jst.jsp.core.internal.validation.JSPELValidator"
			id="org.eclipse.jst.jsp.jspelsourcevalidator">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource">
				<partitionType id="org.eclipse.jst.jsp.SCRIPT.JSP_EL">
				</partitionType>
			</contentTypeIdentifier>
		</validator>
	</extension>
	<!--======================================================================================-->
	<!-- source (as you type) validation for JSP directive			   						  -->
	<!--======================================================================================-->
	<extension point="org.eclipse.wst.sse.ui.sourcevalidation">
		<validator
			scope="total"
			class="org.eclipse.jst.jsp.core.internal.validation.JSPDirectiveValidator"
			id="org.eclipse.jst.jsp.tldsourcevalidator">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource">
				<partitionType id="org.eclipse.jst.jsp.DEFAULT_JSP">
				</partitionType>
				<partitionType id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
				</partitionType>
			</contentTypeIdentifier>
		</validator>
	</extension>
	<!--======================================================================================-->
	<!-- source (as you type) validation for JSP action tags			   					  -->
	<!--======================================================================================-->
	<extension point="org.eclipse.wst.sse.ui.sourcevalidation">
		<validator
			scope="total"
			class="org.eclipse.jst.jsp.ui.internal.validation.JSPActionSourceValidator"
			id="org.eclipse.jst.jsp.ui.internal.validation.jspactionvalidator">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource">
				<partitionType id="org.eclipse.jst.jsp.DEFAULT_JSP">
				</partitionType>
				<partitionType id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
				</partitionType>
			</contentTypeIdentifier>
		</validator>
	</extension>

	<!--======================================================================================-->
	<!-- HTML (as you type) validation					   						  			  -->
	<!--======================================================================================-->
	<extension point="org.eclipse.wst.sse.ui.sourcevalidation">
		<validator
			scope="total"
			class="org.eclipse.jst.jsp.ui.internal.validation.JSPContentSourceValidator"
			id="org.eclipse.jst.jsp.ui.internal.validation.htmlsyntaxvalidator">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource">
				<partitionType id="org.eclipse.jst.jsp.JSP_DIRECTIVE"/>
				<partitionType id="org.eclipse.jst.jsp.JSP_COMMENT"/>
				<partitionType id="org.eclipse.wst.html.HTML_DEFAULT"/>
				<partitionType id="org.eclipse.wst.html.HTML_DECLARATION"/>
				<partitionType id="org.eclipse.wst.html.HTML_COMMENT"/>
				<partitionType id="org.eclipse.wst.xml.XML_DEFAULT"/>
				<partitionType id="org.eclipse.wst.sse.ST_DEFAULT"/>
			</contentTypeIdentifier>
		</validator>
	</extension>

	<!-- for .tagx files -->
	<extension point="org.eclipse.wst.sse.ui.sourcevalidation">
		<validator
			scope="total"
			class="org.eclipse.wst.xml.ui.internal.validation.DelegatingSourceValidatorForXML"
			id="org.eclipse.wst.xml.ui.internal.validation.DelegatingSourceValidatorForXML">
			<contentTypeIdentifier id="org.eclipse.jst.jsp.core.tagxsource">
				<partitionType id="org.eclipse.wst.xml.XML_DEFAULT"/>
				<partitionType id="org.eclipse.wst.xml.XML_COMMENT"/>
				<partitionType id="org.eclipse.wst.sse.ST_DEFAULT"/>
			</contentTypeIdentifier>
		</validator>
	</extension>

	<!--======================================================================================-->
	<!-- JSP UI Adapter factories					   						  				  -->
	<!--======================================================================================-->
	<extension
		point="org.eclipse.wst.sse.ui.adapterFactoryDescription">
		<adapterFactoryDescription
			class="org.eclipse.jst.jsp.ui.internal.registry.AdapterFactoryProviderForJSP">
			<contentType id="org.eclipse.jst.jsp.core.jspsource" />
		</adapterFactoryDescription>
	</extension>

	<extension
		point="org.eclipse.core.filebuffers.annotationModelCreation">
		<factory
			contentTypeId="org.eclipse.jst.jsp.core.jspsource"
			class="org.eclipse.wst.sse.ui.internal.StructuredResourceMarkerAnnotationModelFactory" />
	</extension>

	<extension point="org.eclipse.ui.preferencePages">

		<!--======================================================================================-->
		<!-- JSP PREFERENCE PAGES                                                                 -->
		<!--======================================================================================-->
		<page
			name="%JSP_Files.name"
			category="org.eclipse.wst.html.ui.preferences.web"
			class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPFilesPreferencePage"
			id="org.eclipse.jst.jsp.ui.preferences.jsp">
			<keywordReference id="org.eclipse.jst.jsp.ui.files"/>
		</page>
		<page
			name="%JSP_Source.name"
			category="org.eclipse.jst.jsp.ui.preferences.jsp"
			class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPSourcePreferencePage"
			id="org.eclipse.wst.sse.ui.preferences.jsp.source">
		</page>
  <page
        category="org.eclipse.wst.sse.ui.preferences.jsp.source"
        class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPContentAssistPreferencePage"
        id="org.eclipse.wst.sse.ui.preferences.jsp.contentassist"
        name="%JSP_Content_Assist.name">
     <keywordReference
           id="org.eclipse.jst.jsp.ui.contentassist">
     </keywordReference>
  </page>
		<page
			name="%JSP_Templates.name"
			category="org.eclipse.wst.sse.ui.preferences.jsp.source"
			class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPTemplatePreferencePage"
			id="org.eclipse.wst.sse.ui.preferences.jsp.templates">
			<keywordReference id="org.eclipse.jst.jsp.ui.templates"/>
		</page>
		<page
			name="%JSP_Syntax_Coloring"
			category="org.eclipse.wst.sse.ui.preferences.jsp.source"
			class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPSyntaxColoringPage"
			id="org.eclipse.wst.sse.ui.preferences.jsp.styles">
			<keywordReference id="org.eclipse.jst.jsp.ui.styles"/>
		</page>
		<page
			name="%JSP_Validation"
			category="org.eclipse.jst.jsp.ui.preferences.jsp"
			class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPValidationPreferencePage"
			id="org.eclipse.jst.jsp.ui.preferences.validation">
			<keywordReference id="org.eclipse.jst.jsp.ui.severities"/>
		</page>
		<page
			name="%JSP_Typing"
			category="org.eclipse.wst.sse.ui.preferences.jsp.source"
			class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPTypingPreferencePage"
			id="org.eclipse.jst.jsp.ui.preferences.typing">
		</page>
	</extension>
	
	<!-- Keywords for preference and properties pages -->
	<extension point="org.eclipse.ui.keywords">
		<keyword
			label="%preferenceKeywords.files"
			id="org.eclipse.jst.jsp.ui.files"/>
		<keyword
			label="%preferenceKeywords.contentassist"
			id="org.eclipse.jst.jsp.ui.contentassist"/>
		<keyword
			label="%preferenceKeywords.templates"
			id="org.eclipse.jst.jsp.ui.templates"/>
		<keyword
			label="%preferenceKeywords.styles"
			id="org.eclipse.jst.jsp.ui.styles"/>
		<keyword
			label="%preferenceKeywords.fragments"
			id="org.eclipse.jst.jsp.ui.fragments"/>
		<keyword
			label="%preferenceKeywords.severities"
			id="org.eclipse.jst.jsp.ui.severities"/>
    </extension>

	<!--======================================================================================-->
	<!-- FOR JSP/JAVA RENAME PARTICIPATION                                                    -->
	<!--======================================================================================-->
	<extension
		point="org.eclipse.ltk.core.refactoring.renameParticipants">
		<renameParticipant
			name="%JSP_Type_Rename_Participant_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.java.refactoring.JSPTypeRenameParticipant"
			id="org.eclipse.jst.jsp.ui.java.refactoring.JSPTypeRenameParticipant">
			<enablement>
				<with variable="affectedNatures">
					<iterate operator="or">
						<equals value="org.eclipse.jdt.core.javanature" />

					</iterate>
				</with>
				<with variable="element">
					<instanceof value="org.eclipse.jdt.core.IType" />

				</with>
			</enablement>
		</renameParticipant>

		<renameParticipant
			name="%JSP_Method_Rename_Participant_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.java.refactoring.JSPMethodRenameParticipant"
			id="org.eclipse.jst.jsp.ui.java.refactoring.JSPMethodRenameParticipant">
			<enablement>
				<with variable="affectedNatures">
					<iterate operator="or">
						<equals value="org.eclipse.jdt.core.javanature" />

					</iterate>
				</with>
				<with variable="element">
					<instanceof value="org.eclipse.jdt.core.IMethod" />

				</with>
			</enablement>
		</renameParticipant>

		<renameParticipant
			name="%JSP_Package_Rename_Participant_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.java.refactoring.JSPPackageRenameParticipant"
			id="org.eclipse.jst.jsp.ui.java.refactoring.JSPPackageRenameParticipant">
			<enablement>
				<with variable="affectedNatures">
					<iterate operator="or">
						<equals value="org.eclipse.jdt.core.javanature" />

					</iterate>
				</with>
				<with variable="element">
					<instanceof
						value="org.eclipse.jdt.core.IPackageFragment" />

				</with>
			</enablement>
		</renameParticipant>
		  <renameParticipant
		        class="org.eclipse.jst.jsp.ui.internal.java.refactoring.JSPFieldRenameParticipant"
		        id="org.eclipse.jst.jsp.ui.java.refactoring.JSFieldRenameParticipant"
		        name="%JSP_Field_Rename_Participant_Extension_Element.name">
		     <enablement>
		        <with variable="affectedNatures">
		           <iterate operator="or">
		              <equals value="org.eclipse.jdt.core.javanature">
		              </equals>
		           </iterate>
		        </with>
		        <with variable="element">
		           <instanceof value="org.eclipse.jdt.core.IField">
		           </instanceof>
		        </with>
		     </enablement>
		  </renameParticipant>
	</extension>

	<!--======================================================================================-->
	<!-- FOR JSP/JAVA MOVE PARTICIPATION                                                      -->
	<!--======================================================================================-->
	<extension
		point="org.eclipse.ltk.core.refactoring.moveParticipants">

		<moveParticipant
			id="org.eclipse.jst.jsp.ui.java.refactoring.JSPTypeMoveParticipant"
			name="%JSP_Type_Move_Participant_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.java.refactoring.JSPTypeMoveParticipant">
			<enablement>
				<with variable="affectedNatures">
					<iterate operator="or">
						<equals value="org.eclipse.jdt.core.javanature" />
					</iterate>
				</with>
				<with variable="element">
					<instanceof value="org.eclipse.jdt.core.IType" />

				</with>
			</enablement>
		</moveParticipant>
	</extension>

	<!--======================================================================================-->
	<!-- for breakpoint                                                                       -->
	<!--======================================================================================-->
	<extension point="org.eclipse.wst.sse.ui.breakpoint">
		<breakpointContribution id="org.eclipse.jst.jsp.ui.providers">
			<provider
				contentTypes="org.eclipse.jst.jsp.core.jspsource"
				id="org.eclipse.jst.jsp.ui.internal.breakpointproviders.JavaStratumBreakpointProvider">
				<class class="org.eclipse.jst.jsp.ui.internal.breakpointproviders.JavaStratumBreakpointProvider">
					<parameter name="org.eclipse.jst.jsp.core.jspsource" value="*jsp,jsp_servlet._*"/>
					<parameter name="org.eclipse.jst.jsp.core.tagsource" value="*tag,*tagx,tag._*,tagx._*"/>
				</class>
			</provider>
		</breakpointContribution>
	</extension>

	<!--======================================================================================-->
	<!-- Snippet View contributions                                                           -->
	<!--======================================================================================-->
	<extension
		point="org.eclipse.wst.common.snippets.SnippetContributions">
		<category
			label="%JSP_Extension_Element.label"
			smallicon="icons/snippets/tag-jsp.gif"
			id="org.eclipse.jst.jsp.ui.category0"
			contenttypes="org.eclipse.jst.jsp.core.jspsource">
			<item
				label="%jsp_hidden_comment"
				smallicon="icons/snippets/tag-generic.gif"
				id="org.eclipse.jst.jsp.ui.jsp_hidden_comment">
				<content>%jsp_hidden_comment_content</content>
			</item>
			<item
				label="%jsp_scriptlet"
				smallicon="icons/snippets/jspscr.gif"
				id="org.eclipse.jst.jsp.ui.jsp_scriptlet">
				<content>%jsp_scr_content</content>
			</item>
			<item
				label="%jsp_expression"
				smallicon="icons/snippets/jspexp.gif"
				id="org.eclipse.jst.jsp.ui.jsp_expression">
				<content>%jsp_expression_content</content>
			</item>
			<item
				label="%jsp_declaration"
				smallicon="icons/snippets/jspdecl.gif"
				id="org.eclipse.jst.jsp.ui.jsp_declaration">
				<content>%jsp_declaration_content</content>
			</item>
			<item
				label="%jsp_include_directive"
				smallicon="icons/snippets/jspincl.gif"
				id="org.eclipse.jst.jsp.ui.jsp_include_directive">
				<content>%jsp_include_directive_content</content>
			</item>
			<item
				label="%jsp_page_directive"
				id="org.eclipse.jst.jsp.ui.jsp_page_directive">
				<content>%jsp_page_directive_content</content>
			</item>
			<item
				label="%jsp_taglib_directive"
				smallicon="icons/snippets/jsptaglib.gif"
				id="org.eclipse.jst.jsp.ui.jsp_taglib_directive">
				<content>%jsp_taglib_directive_content</content>
				<variable
					description="%jsp_taglib_directive_uri"
					id="uri" />

				<variable
					default="mylib"
					description="%jsp_taglib_directive_prefix"
					id="prefix" />

			</item>
		</category>
	</extension>

	<!-- Editor actionsets -->
	<extension point="org.eclipse.ui.actionSetPartAssociations">
		<actionSetPartAssociation
			targetID="org.eclipse.ui.edit.text.actionSet.annotationNavigation">
			<part id="org.eclipse.jst.jsp.core.jspsource.source" />
		</actionSetPartAssociation>
		<actionSetPartAssociation
			targetID="org.eclipse.ui.NavigateActionSet">
			<part id="org.eclipse.jst.jsp.core.jspsource.source" />
		</actionSetPartAssociation>
		<actionSetPartAssociation
            targetID="org.eclipse.debug.ui.launchActionSet">
            <part id="org.eclipse.jst.jsp.core.jspsource.source"/>
		</actionSetPartAssociation>
	</extension>

	<!--======================================================================================-->
	<!-- JSP Editor specific actions                                                          -->
	<!--======================================================================================-->
	<extension point="org.eclipse.ui.commands">
		<!-- rename refactor -->
		<command
			name="%command.jsp.refactor.rename.name"
			description="%command.jsp.refactor.rename.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.jst.jsp.ui.refactor.rename" />

		<!-- move refactor -->
		<command
			name="%command.jsp.refactor.move.name"
			description="%command.jsp.refactor.move.description"
			categoryId="org.eclipse.ui.category.edit"
			id="org.eclipse.jst.jsp.ui.refactor.move" />
	</extension>
	
	<!-- Keybinding scope for jsp source editor -->
	<extension point="org.eclipse.ui.contexts">
		<context
			name="%scope.structured.text.editor.jsp.name"
			parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			description="%scope.structured.text.editor.jsp.description"
			id="org.eclipse.jst.jsp.ui.structured.text.editor.jsp.scope">
		</context>
		<context
			name="%scope.jsp.core.jspsource.name"
			parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			description="%scope.jsp.core.jspsource.description"
			id="org.eclipse.jst.jsp.core.jspsource">
		</context>
	</extension>
	
	<!-- Keybindings for jsp source editor -->
	<extension point="org.eclipse.ui.bindings">
	    <!--  win32:  M1=CTRL, M2=SHIFT, M3=ALT -->
		<!-- rename refactor -->
		<key
			sequence="M2+M3+R"
			contextId="org.eclipse.jst.jsp.ui.structured.text.editor.jsp.scope"
			commandId="org.eclipse.jst.jsp.ui.refactor.rename"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>

		<!-- move refactor -->
		<key
			sequence="M2+M3+V"
			contextId="org.eclipse.jst.jsp.ui.structured.text.editor.jsp.scope"
			commandId="org.eclipse.jst.jsp.ui.refactor.move"
			schemeId="org.eclipse.ui.defaultAcceleratorConfiguration">
		</key>
	</extension>

	<!--======================================================================================-->
	<!-- Templates                                                                            -->
	<!--======================================================================================-->
	<extension point="org.eclipse.ui.editors.templates">
		<contextType
			name="%All_JSP_context_type_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.templates.TemplateContextTypeJSP"
			id="jsp_all" />

		<contextType
			name="%JSP_New_context_type_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.templates.TemplateContextTypeJSP"
			id="jsp_new" />

		<contextType
			name="%Tag_New_context_type_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.templates.TemplateContextTypeJSP"
			id="tag_new" />

		<contextType
			name="%JSP_Tag_context_type_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.templates.TemplateContextTypeJSP"
			id="jsp_tag" />

		<contextType
			name="%JSP_Attribute_context_type_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.templates.TemplateContextTypeJSP"
			id="jsp_attribute" />

		<contextType
			name="%JSP_Attribute_value_context_type_Extension_Element.name"
			class="org.eclipse.jst.jsp.ui.internal.templates.TemplateContextTypeJSP"
			id="jsp_attribute_value" />

		<include
			file="templates/jspdefault-templates.xml"
			translations="$nl$/templates/jspdefault-templates.properties" />

	</extension>

	<!--======================================================================================-->
	<!-- queryParticipant to participate in java seraches                                     -->
	<!--======================================================================================-->
	<extension point="org.eclipse.jdt.ui.queryParticipants">
		<queryParticipant
			name="%JSP_Query_Participant_Extension_Element.name"
			nature="org.eclipse.jdt.core.javanature"
			class="org.eclipse.jst.jsp.ui.internal.java.search.ui.JSPQueryParticipant"
			id="org.eclipse.jst.jsp.ui.java.search.ui.JSPQueryParticipant" />

	</extension>
	<!-- initialize xml ui preferences -->
	<extension point="org.eclipse.core.runtime.preferences">
		<initializer
			class="org.eclipse.jst.jsp.ui.internal.preferences.JSPUIPreferenceInitializer" />
	</extension>

	<!--======================================================================================-->
	<!-- Document provider for ExternalFileEditorInput                                        -->
	<!--======================================================================================-->
	<extension point="org.eclipse.ui.editors.documentProviders">
		<provider
			inputTypes="org.eclipse.jst.jsp.ui.internal.hyperlink.ExternalFileEditorInput"
			class="org.eclipse.ui.editors.text.TextFileDocumentProvider"
			id="org.eclipse.jst.jsp.ui.internal.ExternalFileDocumentProvider" />

	</extension>

	<!-- New JSP wizard -->
	<extension point="org.eclipse.ui.newWizards">
		<wizard
			id="org.eclipse.jst.jsp.ui.internal.wizard.NewJSPWizard"
			name="%_UI_WIZARD_NAME"
			class="org.eclipse.jst.jsp.ui.internal.wizard.NewJSPWizard"
			category="org.eclipse.wst.web.ui"
			icon="$nl$/icons/full/etool16/newjsp_wiz.gif">
			<description>%_UI_WIZARD_CREATE_NEW_FILE</description>
			<selection class="org.eclipse.core.resources.IResource" />
		</wizard>

		<wizard
			id="org.eclipse.jst.jsp.ui.internal.wizard.NewTagWizard"
			name="%_UI_WIZARD_TAG_NAME"
			class="org.eclipse.jst.jsp.ui.internal.wizard.NewTagWizard"
			category="org.eclipse.wst.web.ui"
			icon="$nl$/icons/full/etool16/newjsp_wiz.gif">
			<description>%_UI_WIZARD_TAG_CREATE_NEW_FILE</description>
			<selection class="org.eclipse.core.resources.IResource" />
		</wizard>
	</extension>

	<!-- Add new JSP wizard to Project Explorer -->
	<extension
		id="org.eclipse.jst.jsp.commonWizard.newJSP"
		point="org.eclipse.ui.navigator.navigatorContent">
		<commonWizard
        menuGroupId="org.eclipse.wst.web.ui"
        type="new"
        wizardId="org.eclipse.jst.jsp.ui.internal.wizard.NewJSPWizard">
			<enablement>
				<or>
					<adapt type="org.eclipse.core.resources.IResource">
						<test
							property="org.eclipse.wst.common.project.facet.core.projectFacet"
							value="jst.web"/>
					</adapt>
				</or>
			</enablement>
		</commonWizard>
	</extension>

	<extension point="org.eclipse.ui.popupMenus">
		<viewerContribution
			targetID="org.eclipse.jst.jsp.core.jspsource.source.RulerContext"
			id="org.eclipse.ui.texteditor.ruler.context.actions">
			<action
				label="%AddTask.label"
				helpContextId="org.eclipse.ui.AddTask_action_context"
				class="org.eclipse.ui.texteditor.TaskRulerAction"
				tooltip="%AddTask.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.TaskRulerAction" />

			<action
				label="%AddBookmark.label"
				helpContextId="org.eclipse.ui.bookmark_action_context"
				class="org.eclipse.ui.texteditor.BookmarkRulerAction"
				tooltip="%AddBookmark.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.BookmarkRulerAction" />

		</viewerContribution>
		<viewerContribution
			targetID="org.eclipse.jst.jsp.core.jspfragmentsource.source.RulerContext"
			id="org.eclipse.ui.texteditor.ruler.context.actions">
			<action
				label="%AddTask.label"
				helpContextId="org.eclipse.ui.AddTask_action_context"
				class="org.eclipse.ui.texteditor.TaskRulerAction"
				tooltip="%AddTask.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.TaskRulerAction" />

			<action
				label="%AddBookmark.label"
				helpContextId="org.eclipse.ui.bookmark_action_context"
				class="org.eclipse.ui.texteditor.BookmarkRulerAction"
				tooltip="%AddBookmark.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.BookmarkRulerAction" />

		</viewerContribution>
		<viewerContribution
			targetID="org.eclipse.jst.jsp.core.tagsource.source.RulerContext"
			id="org.eclipse.ui.texteditor.ruler.context.actions">
			<action
				label="%AddTask.label"
				helpContextId="org.eclipse.ui.AddTask_action_context"
				class="org.eclipse.ui.texteditor.TaskRulerAction"
				tooltip="%AddTask.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.TaskRulerAction" />

			<action
				label="%AddBookmark.label"
				helpContextId="org.eclipse.ui.bookmark_action_context"
				class="org.eclipse.ui.texteditor.BookmarkRulerAction"
				tooltip="%AddBookmark.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.BookmarkRulerAction" />

		</viewerContribution>
		<viewerContribution
			targetID="org.eclipse.jst.jsp.core.tldsource.source.RulerContext"
			id="org.eclipse.ui.texteditor.ruler.context.actions">
			<action
				label="%AddTask.label"
				helpContextId="org.eclipse.ui.AddTask_action_context"
				class="org.eclipse.ui.texteditor.TaskRulerAction"
				tooltip="%AddTask.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.TaskRulerAction" />

			<action
				label="%AddBookmark.label"
				helpContextId="org.eclipse.ui.bookmark_action_context"
				class="org.eclipse.ui.texteditor.BookmarkRulerAction"
				tooltip="%AddBookmark.tooltip"
				menubarPath="additions"
				id="org.eclipse.ui.texteditor.BookmarkRulerAction" />

		</viewerContribution>
	</extension>

	<extension point="org.eclipse.ui.editorActions">
	<editorContribution
			id="org.eclipse.jst.jsp.core.jspsource.source.editorActions"
			targetID="org.eclipse.jst.jsp.core.jspsource.source">
	<!--		<action
				id="CleanupDocument"
				label="%CleanupDocument_label"
				definitionId="org.eclipse.wst.sse.ui.cleanup.document"
				tooltip="%CleanupDocument_tooltip"
				class="org.eclipse.wst.html.ui.internal.edit.ui.CleanupActionHTMLDelegate"
				actionID="CleanupDocument">
			</action>
			<action
				id="ToggleComment"
				label="%ToggleComment_label"
				definitionId="org.eclipse.wst.sse.ui.toggle.comment"
				tooltip="%ToggleComment_tooltip"
				class="org.eclipse.wst.xml.ui.internal.actions.ToggleCommentActionXMLDelegate"
				actionID="ToggleComment">
			</action>
			<action
				id="AddBlockComment"
				label="%AddBlockComment_label"
				definitionId="org.eclipse.wst.sse.ui.add.block.comment"
				tooltip="%AddBlockComment_tooltip"
				class="org.eclipse.wst.xml.ui.internal.actions.AddBlockCommentActionXMLDelegate"
				actionID="AddBlockComment">
			</action>
			<action
				id="RemoveBlockComment"
				label="%RemoveBlockComment_label"
				definitionId="org.eclipse.wst.sse.ui.remove.block.comment"
				tooltip="%RemoveBlockComment_tooltip"
				class="org.eclipse.wst.xml.ui.internal.actions.RemoveBlockCommentActionXMLDelegate"
				actionID="RemoveBlockComment">
			</action>-->
			<!--<action
				id="RenameElement"
				label="%RenameElement_label"
				definitionId="org.eclipse.jst.jsp.ui.refactor.rename"
				class="org.eclipse.jst.jsp.ui.internal.java.refactoring.JSPRenameElementActionDelegate"
				actionID="RenameElement">
			</action>
			<action
				id="MoveElement"
				label="%MoveElement_label"
				definitionId="org.eclipse.jst.jsp.ui.refactor.move"
				class="org.eclipse.jst.jsp.ui.internal.java.refactoring.JSPMoveElementActionDelegate"
				actionID="MoveElement">
			</action>
			<action
				id="FindOccurrences"
				label="%FindOccurrences_label"
				definitionId="org.eclipse.wst.sse.ui.search.find.occurrences"
				class="org.eclipse.jst.jsp.ui.internal.java.search.JSPFindOccurrencesActionDelegate"
				actionID="FindOccurrences">
			</action>-->
			<!--<action
				id="StructureSelectEnclosing"
				label="%StructureSelectEnclosing_label"
				definitionId="org.eclipse.wst.sse.ui.structure.select.enclosing"
				tooltip="%StructureSelectEnclosing_tooltip"
				class="org.eclipse.wst.xml.ui.internal.selection.StructuredSelectEnclosingXMLActionDelegate"
				actionID="StructureSelectEnclosing">
			</action>
			<action
				id="StructureSelectNext"
				label="%StructureSelectNext_label"
				definitionId="org.eclipse.wst.sse.ui.structure.select.next"
				tooltip="%StructureSelectNext_tooltip"
				class="org.eclipse.wst.xml.ui.internal.selection.StructuredSelectNextXMLActionDelegate"
				actionID="StructureSelectNext">
			</action>
			<action
				id="StructureSelectPrevious"
				label="%StructureSelectPrevious_label"
				definitionId="org.eclipse.wst.sse.ui.structure.select.previous"
				tooltip="%StructureSelectPrevious_tooltip"
				class="org.eclipse.wst.xml.ui.internal.selection.StructuredSelectPreviousXMLActionDelegate"
				actionID="StructureSelectPrevious">
			</action>
			<action
				id="StructureSelectHistory"
				label="%StructureSelectHistory_label"
				definitionId="org.eclipse.wst.sse.ui.structure.select.last"
				tooltip="%StructureSelectHistory_tooltip"
				class="org.eclipse.wst.sse.ui.internal.selection.StructuredSelectHistoryActionDelegate"
				actionID="StructureSelectHistory">
			</action>-->
		</editorContribution>
        <editorContribution
            targetID="org.eclipse.jst.jsp.core.jspsource.source"
            id="org.eclipse.jst.jsp.core.jspsource.ruler.actions">
         <action
               label="%AddBookmark.label"
               helpContextId="org.eclipse.ui.bookmark_action_context"
               class="org.eclipse.ui.texteditor.BookmarkRulerAction"
               actionID="RulerDoubleClick"
               id="org.eclipse.ui.texteditor.BookmarkRulerAction"/>
         <action
               label="%SelectRuler.label"
               class="org.eclipse.ui.texteditor.SelectRulerAction"
               actionID="RulerClick"
               id="org.eclipse.ui.texteditor.SelectRulerAction"/>
        </editorContribution>
	</extension>
	
	<extension
       point="org.eclipse.ui.handlers">
       <handler
             class="org.eclipse.jst.jsp.ui.internal.java.refactoring.RenameElementHandler"
             commandId="org.eclipse.jst.jsp.ui.refactor.rename">
             <activeWhen>
             	<reference
                    definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition">
             	</reference>
             </activeWhen>
             <enabledWhen>
             	<reference
                    definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition">
             	</reference>
             </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.jst.jsp.ui.internal.java.refactoring.MoveElementHandler"
             commandId="org.eclipse.jst.jsp.ui.refactor.move">
             <activeWhen>
             	<reference
                    definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition">
             	</reference>
             </activeWhen>
             <enabledWhen>
             	<reference
                    definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition">
             	</reference>
             </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.jst.jsp.ui.internal.handlers.JSPFindOccurrencesHandler"
             commandId="org.eclipse.wst.sse.ui.search.find.occurrences">
             <activeWhen>
             	<reference
                    definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition">
             	</reference>
             </activeWhen>
             <enabledWhen>
             	<reference
                    definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition">
             	</reference>
             </enabledWhen>
       </handler>
	</extension>
	
	<extension point="org.eclipse.ui.perspectiveExtensions">
        <perspectiveExtension targetID="org.eclipse.wst.web.ui.webDevPerspective">
            <newWizardShortcut id="org.eclipse.jst.jsp.ui.internal.wizard.NewJSPWizard"/>
        </perspectiveExtension> 
	</extension>
	
	<!-- JSP Fragment Property Page -->
	<extension point="org.eclipse.ui.propertyPages">
		<!-- for j2ee web project -->
		<page
			name="%JSPFragmentContentSettings.name"
			class="org.eclipse.jst.jsp.ui.internal.contentproperties.ui.ProjectJSPFContentSettingsPropertyPage"
			id="org.eclipse.jst.jsp.ui.internal.contentproperties.ProjectJSPFContentSettingsPropertyPage">
         	<enabledWhen>
               	<and>
					<adapt type="org.eclipse.core.resources.IProject">
						<or> 
							<test 
								forcePluginActivation="true"
								property="org.eclipse.wst.common.project.facet.core.projectFacet"
								value="jst.web" />
						</or>
					</adapt>
				</and> 
			</enabledWhen>
			<keywordReference id="org.eclipse.jst.jsp.ui.fragments"/>
		</page>
		<page
			name="%JSPFragmentContentSettings.name"
			class="org.eclipse.jst.jsp.ui.internal.contentproperties.ui.JSPFContentSettingsPropertyPage"
			id="org.eclipse.jst.jsp.ui.internal.contentproperties.JSPFContentSettingsPropertyPage">
         	<enabledWhen>
               	<and>
					<adapt type="org.eclipse.core.resources.IFile">
						<or> 
							<test 
								forcePluginActivation="true"
								property="org.eclipse.core.resources.contentTypeId"
								value="org.eclipse.jst.jsp.core.jspfragmentsource" />
							<test 
								forcePluginActivation="true"
								property="org.eclipse.core.resources.contentTypeId"
								value="org.eclipse.jst.jsp.core.cssjspfragmentsource" />
						</or>
					</adapt>
				</and> 
			</enabledWhen>
			<keywordReference id="org.eclipse.jst.jsp.ui.fragments"/>
		</page>
		<page
			name="%JSP_Property_validation" 
			class="org.eclipse.jst.jsp.ui.internal.preferences.ui.JSPValidationPreferencePage"
			id="org.eclipse.jst.jsp.ui.propertyPage.project.validation"
			category="ValidationPropertiesPage">
			<enabledWhen>
				<adapt type="org.eclipse.core.resources.IProject">
					<test property="org.eclipse.core.resources.projectNature" value="org.eclipse.jdt.core.javanature"/>
				</adapt>
			</enabledWhen>
			<keywordReference id="org.eclipse.jst.jsp.ui.severities"/>
		</page>
		<page
			name="%JSP_Property_tag_contentSettings"
			class="org.eclipse.jst.jsp.ui.internal.contentproperties.ui.TagContentSettingsPropertyPage"
			id="org.eclipse.jst.jsp.ui.propertyPage.project.tag.content.settings"
			category="org.eclipse.ui.propertypages.info.file">
         	<enabledWhen>
               	<and>
					<adapt type="org.eclipse.core.resources.IFile">
						<or> 
							<test 
								forcePluginActivation="true"
								property="org.eclipse.core.resources.contentTypeId"
								value="org.eclipse.jst.jsp.core.tagsource" />
						</or>
					</adapt>
				</and> 
			</enabledWhen>
		</page>
	</extension>	
	<!--  jsp-for-css editor configurations -->		
	<extension point="org.eclipse.wst.sse.ui.editorConfiguration">
		<contentOutlineConfiguration
			class="org.eclipse.wst.css.ui.views.contentoutline.CSSContentOutlineConfiguration"
			target="org.eclipse.jst.jsp.core.cssjspsource" />
		<sourceViewerConfiguration
			class="org.eclipse.wst.css.ui.StructuredTextViewerConfigurationCSS"
			target="org.eclipse.jst.jsp.core.cssjspsource" />
		<propertySheetConfiguration
			class="org.eclipse.jst.jsp.css.ui.internal.views.properties.JSPedCSSPropertySheetConfiguration"
			target="org.eclipse.jst.jsp.core.cssjspsource" />
		<provisionalConfiguration
			type="characterpairmatcher"
			class="org.eclipse.wst.css.ui.internal.text.CSSDocumentRegionEdgeMatcher"
			target="org.eclipse.jst.jsp.core.cssjspsource" />
		<provisionalConfiguration
			type="foldingstrategy"
			class="org.eclipse.wst.css.ui.internal.projection.CSSFoldingStrategy"
			target="org.eclipse.jst.jsp.core.cssjspsource" />
		<provisionalDefinition
			type="preferencepages"
			value="org.eclipse.wst.sse.ui.preferences.css, org.eclipse.wst.sse.ui.preferences.css.source, org.eclipse.wst.css.ui.preferences.templates, org.eclipse.wst.sse.ui.preferences.css.styles"
			target="org.eclipse.jst.jsp.core.cssjspsource" />
	</extension>
		<extension
		point="org.eclipse.wst.sse.ui.adapterFactoryDescription">
		<adapterFactoryDescription
			class="org.eclipse.jst.jsp.css.ui.internal.registry.AdapterFactoryProviderJSPedCSS">
			<contentType id="org.eclipse.jst.jsp.core.cssjspsource" />
		</adapterFactoryDescription>
	</extension>
	<extension
		point="org.eclipse.ui.workbench.texteditor.hyperlinkDetectorTargets">
		<target
			id="org.eclipse.jst.jsp.core.jspsource"
			name="%JSP_Source_target_name">
		</target>
	</extension>
	<extension
		point="org.eclipse.ui.workbench.texteditor.hyperlinkDetectors">
		<hyperlinkDetector
			class="org.eclipse.jst.jsp.ui.internal.hyperlink.JSPJavaHyperlinkDetector"
			id="org.eclipse.jst.jsp.ui.internal.hyperlink.JSPJavaHyperlinkDetector"
			name="%Java_Element_hyperlink"
			targetId="org.eclipse.jst.jsp.core.jspsource">
		</hyperlinkDetector>
		<hyperlinkDetector
			class="org.eclipse.jst.jsp.ui.internal.hyperlink.TaglibHyperlinkDetector"
			id="org.eclipse.jst.jsp.ui.internal.hyperlink.TaglibHyperlinkDetector"
			name="%Taglib_hyperlink"
			targetId="org.eclipse.jst.jsp.core.jspsource">
		</hyperlinkDetector>
		<hyperlinkDetector
			class="org.eclipse.jst.jsp.ui.internal.hyperlink.XMLJavaHyperlinkDetector"
			id="org.eclipse.jst.jsp.ui.internal.hyperlink.XMLJavaHyperlinkDetector"
			name="%Java_Element_hyperlink"
			targetId="org.eclipse.core.runtime.xml">
		</hyperlinkDetector>
   </extension>
   
   <extension point="org.eclipse.core.expressions.definitions">
		<definition id="org.eclipse.wst.jsp.ui.jspSourceContributions.definition">
            <with variable="activeContexts">
	           <iterate operator="or">
	              <equals value="org.eclipse.jst.jsp.core.jspsource"/>
	           </iterate>
            </with>
		</definition>
	</extension>
	
	<extension point="org.eclipse.ui.menus">
	    <menuContribution locationURI="menu:refactorMenuId">
	       <separator name="jspRefactorBegin" visible="false"></separator>
	       <command commandId="org.eclipse.jst.jsp.ui.refactor.rename" id="RenameElement" label="%command.jsp.refactor.rename.name" style="push">
			   <visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition"></reference>
				</visibleWhen>
	       </command>
	       <command commandId="org.eclipse.jst.jsp.ui.refactor.move" id="MoveElement" label="%command.jsp.refactor.move.name" style="push">
			   <visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition"></reference>
				</visibleWhen>
	       </command>
	       <separator name="jspRefactorBegin" visible="false"></separator>
		</menuContribution>
		<menuContribution
			locationURI="popup:refactorPopupMenuId">
			<separator name="jspRefactorBegin" visible="false"></separator>
			<command commandId="org.eclipse.jst.jsp.ui.refactor.rename" id="RenameElement" label="%command.jsp.refactor.rename.name" style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition"></reference>
				</visibleWhen>
			</command>
			<command commandId="org.eclipse.jst.jsp.ui.refactor.move" id="MoveElement" label="%command.jsp.refactor.move.name" style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.jsp.ui.jspSourceContributions.definition"></reference>
				</visibleWhen>
			</command>
			<separator name="jspRefactorBegin" visible="false"></separator>
		</menuContribution>
	</extension>
	
	<!-- Enable the FormatHandler for JSP Content Type -->
	<extension point="org.eclipse.ui.handlers">
		<handler 
			class="org.eclipse.wst.sse.ui.internal.handlers.FormatHandler"
			commandId="org.eclipse.wst.sse.ui.format">
			<activeWhen>
				<reference definitionId="org.eclipse.wst.jsp.ui.jspContentType.definition"></reference>
			</activeWhen>
			<enabledWhen>
				<reference definitionId="org.eclipse.wst.jsp.ui.jspContentType.definition"></reference>
			</enabledWhen>
		</handler>
	</extension>
	
	<!-- Set up a definition for JSP Content Types -->
	<extension point="org.eclipse.core.expressions.definitions">
		<definition id="org.eclipse.wst.jsp.ui.jspContentType.definition">
			<iterate ifEmpty="false">
				<adapt type="org.eclipse.core.resources.IFile">
					<!-- Force property tester to load, should not cause entire plug-in to start -->
					<test property="org.eclipse.wst.sse.core.resources.contentTypeId"
						value="org.eclipse.jst.jsp.core.jspsource" forcePluginActivation="true"/>
				</adapt>
			</iterate>
		</definition>
	</extension>
	<extension point="org.eclipse.wst.sse.ui.characterPairing">
		<inserter class="org.eclipse.wst.html.ui.internal.text.CharacterPairInserter" id="org.eclipse.wst.jsp.ui.inserter">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource"
				partitions="org.eclipse.jst.jsp.JSP_DIRECTIVE,org.eclipse.wst.html.HTML_DEFAULT,org.eclipse.wst.html.HTML_DECLARATION">
			</contentTypeIdentifier>
		</inserter>
	</extension>
	<extension point="org.eclipse.wst.sse.ui.characterPairing">
		<inserter class="org.eclipse.jst.jsp.ui.internal.text.JavaCharacterPairInserter" id="org.eclipse.wst.jsp.java.ui.inserter">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource"
				partitions="org.eclipse.jst.jsp.SCRIPT.JAVA">
			</contentTypeIdentifier>
		</inserter>
	</extension>
	<extension point="org.eclipse.wst.sse.ui.characterPairing">
		<inserter class="org.eclipse.wst.css.ui.internal.text.CSSCharacterPairInserter" id="org.eclipse.jst.jsp.css.ui.inserter">
			<contentTypeIdentifier
				id="org.eclipse.jst.jsp.core.jspsource"
				partitions="org.eclipse.wst.css.STYLE">
			</contentTypeIdentifier>
		</inserter>
	</extension>
 <extension
       point="org.eclipse.wst.sse.ui.commentingStrategy">
    <blockCommentingStrategy
          prefix="&lt;!--"
          suffix="--&gt;">
       <contentType
             associatedCommentPartitionTypeID="org.eclipse.wst.html.HTML_COMMENT"
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes>
             <partitionType
                   id="org.eclipse.wst.html.HTML_DEFAULT">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.HTML_DECLARATION">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.SCRIPT.EVENTHANDLER">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.xml.XML_PI">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="false">
             <partitionType
                   id="org.eclipse.wst.css.STYLE">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.SCRIPT">
             </partitionType>
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
    <blockCommentingStrategy
          prefix="&lt;%--"
          suffix="--%&gt;">
       <contentType
             associatedCommentPartitionTypeID="org.eclipse.jst.jsp.JSP_COMMENT"
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes>
             <partitionType
                   id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.DEFAULT_JSP">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.DELIMITER">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JSP_EL">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JSP_EL2">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="true">
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
    <blockCommentingStrategy
          prefix="/*"
          suffix="*/">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JAVA">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="false">
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
    <lineCommentingStrategy
          prefix="//">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JAVA">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="false">
          </allowablePartitionTypes>
       </contentType>
    </lineCommentingStrategy>
 </extension>
 <extension
       point="org.eclipse.wst.sse.ui.completionProposal">
    <proposalCategory
          icon="icons/full/obj16/tag-template.gif"
          id="org.eclipse.jst.jsp.ui.proposalCategory.jspTemplates"
          name="%proposalCategory.jspTemplates">
    </proposalCategory>
    <proposalCategory
          icon="icons/full/obj16/tag-jsp.gif"
          id="org.eclipse.jst.jsp.ui.proposalCategory.jsp"
          name="%proposalCategory.jsp">
    </proposalCategory>
    <proposalCategory
          icon="icons/full/elcl16/javaassist_co.gif"
          id="org.eclipse.jst.jsp.ui.proposalCategory.jspJava"
          name="%proposalCategory.jspJava">
    </proposalCategory>
    <proposalComputerExtendedActivation
          id="org.eclipse.wst.html.ui.proposalComputer.htmlTags">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.html.HTML_DEFAULT">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.html.HTML_COMMENT">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.sse.ST_DEFAULT">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.JSP_COMMENT">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
          </partitionType>
       </contentType>
    </proposalComputerExtendedActivation>
    <proposalComputerExtendedActivation
          id="org.eclipse.wst.html.ui.proposalComputer.htmlTemplates">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.html.HTML_DEFAULT">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.html.HTML_COMMENT">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.sse.ST_DEFAULT">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.JSP_COMMENT">
          </partitionType>
       </contentType>
    </proposalComputerExtendedActivation>
    <proposalComputerExtendedActivation
          id="org.eclipse.wst.xml.ui.proposalComputer.xmlTags">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.xml.XML_DEFAULT">
          </partitionType>
       </contentType>
    </proposalComputerExtendedActivation>
    <proposalComputerExtendedActivation
          id="org.eclipse.wst.xml.ui.proposalComputer.xmlTemplates">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.xml.XML_DEFAULT">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
          </partitionType>
       </contentType>
    </proposalComputerExtendedActivation>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jspTemplates"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPTemplatesCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jspTemplates">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.html.HTML_DEFAULT">
          </partitionType>
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jsp"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jsp">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jsp"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.LibraryTagsCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.libraryTags">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.html.HTML_DEFAULT">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.html.HTML_COMMENT">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.sse.ST_DEFAULT">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.JSP_COMMENT">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
          </partitionType>
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jspJava"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPJavaCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jspJava">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.jst.jsp.SCRIPT.JAVA">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.xml.XML_CDATA">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.DEFAULT_JSP">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.SCRIPT.DELIMITER">
          </partitionType>
          <partitionType
                id="org.eclipse.jst.jsp.SCRIPT.JAVASCRIPT">
          </partitionType>
          <partitionType
                id="org.eclipse.wst.html.SCRIPT">
          </partitionType>
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jspJava"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPELCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jspEL">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.jst.jsp.SCRIPT.JSP_EL">
          </partitionType>
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jspJava"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPImportCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jspImport">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
          </partitionType>
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jsp"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPPropertyCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jspProperty">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jsp"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPUseBeanCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jspUseBean">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
       </contentType>
    </proposalComputer>
    <proposalComputer
          activate="false"
          categoryId="org.eclipse.jst.jsp.ui.proposalCategory.jsp"
          class="org.eclipse.jst.jsp.ui.internal.contentassist.JSPTaglibCompletionProposalComputer"
          id="org.eclipse.jst.jsp.ui.proposalComputer.jspTaglib">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
       </contentType>
    </proposalComputer>
    <proposalComputerExtendedActivation
          id="org.eclipse.wst.css.ui.proposalComputer.css">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.css.STYLE">
          </partitionType>
       </contentType>
    </proposalComputerExtendedActivation>
    <proposalComputerExtendedActivation
          id="org.eclipse.wst.css.ui.proposalComputer.cssTemplates">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <partitionType
                id="org.eclipse.wst.css.STYLE">
          </partitionType>
       </contentType>
    </proposalComputerExtendedActivation>
 </extension>
  <extension
       point="org.eclipse.wst.sse.ui.completionProposalCategoriesConfiguration">
    <categoriesConfiguration
          class="org.eclipse.jst.jsp.ui.internal.preferences.JSPCompletionProposalCategoriesConfiguration"
          contentTypeID="org.eclipse.jst.jsp.core.jspsource">
    </categoriesConfiguration>
 </extension>
<extension
	   point="org.eclipse.wst.sse.ui.outlineFilters">
	   <filter
	        targetId="org.eclipse.jst.jsp.ui.OutlinePage"
	        name="%HideImportDeclaration.label"
	        enabled="false"
	        description="%HideImportDeclaration.description"
	        class="org.eclipse.jst.jsp.ui.views.contentoutline.JSPImportDirectiveFilter"
	        id="org.eclipse.jst.jsp.ui.views.contentoutline.JSPImportDirectiveFilter">
	   </filter>
	   <filter
            targetId="org.eclipse.jst.jsp.ui.OutlinePage"
            name="%HideComments.label"
            enabled="false"
            description="%HideComments.description"
            class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter"
            id="org.eclipse.jst.jsp.ui.views.contentoutline.XMLCommentFilter">
      </filter>
</extension>
</plugin>
