Attachment #183248 for bug #109045

Lines 112-114 Link Here

(-)plugin.properties (+6 lines)
112	proposalCategory.jspTemplates=JSP Template Proposals	112	proposalCategory.jspTemplates=JSP Template Proposals
113	proposalCategory.jsp=JSP Proposals	113	proposalCategory.jsp=JSP Proposals
114	proposalCategory.jspJava=JSP Java Proposals	114	proposalCategory.jspJava=JSP Java Proposals
		115
		116	##
		117	HideImportDeclaration.label=Import Directive
		118	HideImportDeclaration.description=Hides Import Directives
		119	HideComments.label=Comments
		120	HideComments.description=Hides Comments




          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>

Lines 278-285 Link Here

(-)src/org/eclipse/jst/jsp/ui/internal/views/contentoutline/TLDContentOutlineConfiguration.java (-3 / +3 lines)
278	update();	278	update();
279	}	279	}
280		280
281	/*	281
282	* (non-Javadoc)	282	/* (non-Javadoc)
283	*	283	*
284	* @see org.eclipse.ui.texteditor.IUpdate#update()	284	* @see org.eclipse.ui.texteditor.IUpdate#update()
285	*/	285	*/
Lines 343-349 Link Here
343	* org.eclipse.wst.sse.ui.views.contentoutline.ContentOutlineConfiguration	343	* org.eclipse.wst.sse.ui.views.contentoutline.ContentOutlineConfiguration
344	* #getPreferenceStore()	344	* #getPreferenceStore()
345	*/	345	*/
346	protected IPreferenceStore getPreferenceStore() {	346	public IPreferenceStore getPreferenceStore() {
347	return JSPUIPlugin.getDefault().getPreferenceStore();	347	return JSPUIPlugin.getDefault().getPreferenceStore();
348	}	348	}
349	}	349	}




	// be used
	// private StructuredContentOutlineConfiguration fEmbeddedConfiguration =
	// null;
	private final String OUTLINE_FILTER_PREF = "org.eclipse.jst.jsp.ui.OutlinePage"; //$NON-NLS-1$
	/**
	 * Create new instance of JSPContentOutlineConfiguration
	 */

	 * 
	 * @see org.eclipse.wst.sse.ui.views.contentoutline.ContentOutlineConfiguration#getPreferenceStore()
	 */
	public IPreferenceStore getPreferenceStore() {
		return JSPUIPlugin.getDefault().getPreferenceStore();
	}
	
	protected XMLNodeActionManager createNodeActionManager(TreeViewer treeViewer) {
		return new JSPNodeActionManager((IStructuredModel) treeViewer.getInput(), treeViewer);
	}
	
	public String getOutlineFilterTarget(){
		return OUTLINE_FILTER_PREF ;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.jst.jsp.ui.views.contentoutline;

import org.eclipse.jdt.internal.ui.filters.ImportDeclarationFilter;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.JSP20TLDNames;
import org.eclipse.jst.jsp.core.internal.provisional.JSP11Namespace;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class JSPImportDirectiveFilter extends ImportDeclarationFilter {


	/*
	 * @see ViewerFilter
	 */
	public boolean select(Viewer viewer, Object parent, Object element) {
		if (super.select(viewer, parent, element)){
			if (element instanceof Node){
				Node node = (Node)element;
				if (node.getNodeName().equalsIgnoreCase(JSP11Namespace.ElementName.DIRECTIVE_PAGE)){
						NamedNodeMap nodeMap = node.getAttributes();
						for (int i=0;i <nodeMap.getLength();i++){
							Node attr = nodeMap.item(i);
							if (attr.toString().equalsIgnoreCase(JSP20TLDNames.IMPORT))
								return false;
						}
				}
			}
			return true;
		}
		else
			return false;
	}
}

Lines 82-84 Link Here

(-)plugin.properties (+3 lines)
82		82
83	proposalCategory.css=CSS Proposals	83	proposalCategory.css=CSS Proposals
84	proposalCategory.cssTemplates=CSS Template Proposals	84	proposalCategory.cssTemplates=CSS Template Proposals
		85
		86	HideComments.label=Comments
		87	HideComments.description=Hides Comments

Lines 738-741 Link Here

(-)plugin.xml (+11 lines)
738	contentTypeID="org.eclipse.wst.css.core.csssource">	738	contentTypeID="org.eclipse.wst.css.core.csssource">
739	</categoriesConfiguration>	739	</categoriesConfiguration>
740	</extension>	740	</extension>
		741	<extension
		742	point="org.eclipse.wst.sse.ui.outlineFilters">
		743	<filter
		744	targetId="org.eclipse.wst.css.ui.OutlinePage"
		745	name="%HideComments.label"
		746	enabled="false"
		747	description="%HideComments.description"
		748	class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter"
		749	id="org.eclipse.wst.css.ui.views.contentoutline.XMLCommentFilter">
		750	</filter>
		751	</extension>
741	</plugin>	752	</plugin>

Lines 33-38 Link Here

(-)src/org/eclipse/wst/css/ui/views/contentoutline/CSSContentOutlineConfiguration.java (+6 lines)
33	private IContentProvider fContentProvider = null;	33	private IContentProvider fContentProvider = null;
34	private ILabelProvider fLabelProvider = null;	34	private ILabelProvider fLabelProvider = null;
35	private final String OUTLINE_SORT_PREF = "outline-sort"; //$NON-NLS-1$	35	private final String OUTLINE_SORT_PREF = "outline-sort"; //$NON-NLS-1$
		36	private final String OUTLINE_FILTER_PREF = "org.eclipse.wst.css.ui.OutlinePage"; //$NON-NLS-1$
		37
36		38
37	/**	39	/**
38	* Create new instance of CSSContentOutlineConfiguration	40	* Create new instance of CSSContentOutlineConfiguration
Lines 118-121 Link Here
118	}	120	}
119	return filteredSelection;	121	return filteredSelection;
120	}	122	}
		123
		124	protected String getOutlineFilterTarget(){
		125	return OUTLINE_FILTER_PREF ;
		126	}
121	}	127	}

Lines 59-65 Link Here

(-)src/org/eclipse/wst/dtd/ui/views/contentoutline/DTDContentOutlineConfiguration.java (-1 / +6 lines)
59	private Map fViewerContributions;	59	private Map fViewerContributions;
60	private final String OUTLINE_ORDER_PREF = "outline-order"; //$NON-NLS-1$	60	private final String OUTLINE_ORDER_PREF = "outline-order"; //$NON-NLS-1$
61	private final String OUTLINE_SORT_PREF = "outline-sort"; //$NON-NLS-1$	61	private final String OUTLINE_SORT_PREF = "outline-sort"; //$NON-NLS-1$
62		62	private final String OUTLINE_FILTER_PREF = "org.eclipse.wst.dtd.ui.OutlinePage"; //$NON-NLS-1$
		63
63	/**	64	/**
64	* Default constructor for DTDContentOutlineConfiguration.	65	* Default constructor for DTDContentOutlineConfiguration.
65	*/	66	*/
Lines 279-282 Link Here
279	fMenuHelper = null;	280	fMenuHelper = null;
280	}	281	}
281	}	282	}
		283
		284	protected String getOutlineFilterTarget(){
		285	return OUTLINE_FILTER_PREF ;
		286	}
282	}	287	}

Lines 80-82 Link Here

(-)plugin.properties (+3 lines)
80		80
81	proposalCategory.htmlTags=HTML Tag Proposals	81	proposalCategory.htmlTags=HTML Tag Proposals
82	proposalCategory.htmlTemplates=HTML Template Proposals	82	proposalCategory.htmlTemplates=HTML Template Proposals
		83
		84	HideComments.label=Comments
		85	HideComments.description=Hides Comments




          contentTypeID="org.eclipse.wst.html.core.htmlsource">
    </categoriesConfiguration>
 </extension>
 
<extension
      point="org.eclipse.wst.sse.ui.outlineFilters">
      <filter
            targetId="org.eclipse.wst.html.ui.OutlinePage"
            name="%HideComments.label"
            enabled="false"
            description="%HideComments.description"
            class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter"
            id="org.eclipse.wst.html.ui.views.contentoutline.XMLCommentFilter">
      </filter>
</extension>
	
</plugin>

Lines 1-5 Link Here

(-)src/org/eclipse/wst/html/ui/views/contentoutline/HTMLContentOutlineConfiguration.java (-2 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2005 IBM Corporation and others.	2	* Copyright (c) 2004, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 25-31 Link Here
25	* @since 1.0	25	* @since 1.0
26	*/	26	*/
27	public class HTMLContentOutlineConfiguration extends XMLContentOutlineConfiguration {	27	public class HTMLContentOutlineConfiguration extends XMLContentOutlineConfiguration {
28		28	private final String OUTLINE_FILTER_PREF = "org.eclipse.wst.html.ui.OutlinePage"; //$NON-NLS-1$
29	/**	29	/**
30	* Create new instance of HTMLContentOutlineConfiguration	30	* Create new instance of HTMLContentOutlineConfiguration
31	*/	31	*/
Lines 41-44 Link Here
41	protected IPreferenceStore getPreferenceStore() {	41	protected IPreferenceStore getPreferenceStore() {
42	return HTMLUIPlugin.getDefault().getPreferenceStore();	42	return HTMLUIPlugin.getDefault().getPreferenceStore();
43	}	43	}
		44
		45	protected String getOutlineFilterTarget(){
		46	return OUTLINE_FILTER_PREF ;
		47	}
44	}	48	}

Lines 109-111 Link Here

(-)plugin.properties (+5 lines)
109	Colors.content_assist_proposals_foreground=Content Assist Proposals Foreground	109	Colors.content_assist_proposals_foreground=Content Assist Proposals Foreground
110	Colors.content_assist_parameters_background=Content Assist Parameters Background	110	Colors.content_assist_parameters_background=Content Assist Parameters Background
111	Colors.content_assist_parameters_foreground=Content Assist Parameters Foreground	111	Colors.content_assist_parameters_foreground=Content Assist Parameters Foreground
		112
		113	#outline filter
		114	outlineFiltersName=Outline Filters
		115
		116	command.outline.customFilter=Filters

Lines 23-30 Link Here

(-)plugin.xml (-2 / +45 lines)
23	id="characterPairing"	23	id="characterPairing"
24	name="%Character_Pairing.name"	24	name="%Character_Pairing.name"
25	schema="schema/characterPairing.exsd" ></extension-point>	25	schema="schema/characterPairing.exsd" ></extension-point>
26		26	<extension-point
27		27	id="outlineFilters"
		28	name="%outlineFiltersName"
		29	schema="schema/outlineFilters.exsd">
		30	</extension-point>
		31
28	<!-- Make sure default preference values are set at runtime -->	32	<!-- Make sure default preference values are set at runtime -->
29	<extension point="org.eclipse.core.runtime.preferences">	33	<extension point="org.eclipse.core.runtime.preferences">
30	<initializer	34	<initializer
Lines 679-688 Link Here
679	</command>	683	</command>
680		684
681	</menuContribution>	685	</menuContribution>
		686	<!-- content outline -->
		687	<menuContribution locationURI="menu:org.eclipse.ui.views.ContentOutline?after=additions">
		688	<command
		689	commandId="org.eclipse.wst.sse.ui.outline.customFilter"
		690	id="org.eclipse.wst.sse.ui.outline.customFilter"
		691	label="%command.outline.customFilter"
		692	icon ="icons/full/elcl16/filter_ps.gif"
		693	style="push">
		694	<visibleWhen checkEnabled="false">
		695	<with variable="activeEditor">
		696	<test
		697	property="org.eclipse.wst.sse.ui.outline.isConfigurableOutlinePage"
		698	value="true">
		699	</test>
		700
		701	</with>
		702	</visibleWhen>
		703	</command>
		704	</menuContribution>
682	</extension>	705	</extension>
683	<extension	706	<extension
684	point="org.eclipse.ui.commands">	707	point="org.eclipse.ui.commands">
685	<command	708	<command
		709	id="org.eclipse.wst.sse.ui.outline.customFilter"
		710	name="%command.outline.customFilter">
		711	</command>
		712	<command
686	id="org.eclipse.wst.sse.ui.format"	713	id="org.eclipse.wst.sse.ui.format"
687	name="%command.format.document.name">	714	name="%command.format.document.name">
688	</command>	715	</command>
Lines 708-713 Link Here
708	</iterate>	735	</iterate>
709	</enabledWhen>	736	</enabledWhen>
710	</handler>	737	</handler>
		738
		739	<handler
		740	class="org.eclipse.wst.sse.ui.internal.handlers.CustomFilterHandler"
		741	commandId="org.eclipse.wst.sse.ui.outline.customFilter">
		742	</handler>
		743
711	</extension>	744	</extension>
712		745
713	<extension point="org.eclipse.core.expressions.definitions">	746	<extension point="org.eclipse.core.expressions.definitions">
Lines 768-772 Link Here
768	</colorDefinition>	801	</colorDefinition>
769	</extension>	802	</extension>
770		803
		804	<extension
		805	point="org.eclipse.core.expressions.propertyTesters">
		806	<propertyTester
		807	class="org.eclipse.wst.sse.ui.internal.handlers.CustomFilterPropertyTester"
		808	id="org.eclipse.wst.sse.ui.internal.handlers.CustomFilterPropertyTester"
		809	namespace="org.eclipse.wst.sse.ui.outline"
		810	properties="isConfigurableOutlinePage"
		811	type="org.eclipse.ui.IEditorPart">
		812	</propertyTester>
		813	</extension>
771	</plugin>	814	</plugin>
772		815




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.wst.sse.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.wst.sse.ui" id="outlineFilters" name="%outlineFiltersName"/>
      </appInfo>
      <documentation>
         [Enter description of this extension point.]
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence>
            <element ref="filter" minOccurs="1" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  a fully qualified identifier of the target extension point
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  an optional identifier of the extension instance
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  an optional name of the extension instance
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="filter">
      <annotation>
         <appInfo>
            <meta.element labelAttribute="name"/>
         </appInfo>
      </annotation>
      <complexType>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  a unique id that will be used to identify this filter
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  a unique name that allows to identify this filter in the UI. This attribute should be a translated string. Though this attribute is not required for pattern filters (i.e. those using the &lt;samp&gt;pattern&lt;/samp&gt; attribute) we suggest to provide a name anyway, otherwise the pattern string itself would be used to represent the filter in the UI.
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="description" type="string">
            <annotation>
               <documentation>
                  a short description for this filter
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="targetId" type="string">
            <annotation>
               <documentation>
                  the id of the target where this filter is contributed.  If this attribute is missing, then the filter will
be contributed to all views which use the &lt;code&gt;org.eclipse.wst.sse.ui.actions.CustomFiltersAction&lt;/code&gt;.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="enabled" type="boolean">
            <annotation>
               <documentation>
                  the filter will be enabled if this attribute is &quot;true&quot; or if this attribute is not present. Most likely the user will be able to override this setting in the UI.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="class" type="string">
            <annotation>
               <documentation>
                  the name of the class used to filter the view.  The class must extend &lt;code&gt;org.eclipse.jface.viewers.ViewerFilter&lt;/code&gt;. If this attribute is here
then the pattern attribute must not provided.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.jface.viewers.ViewerFilter"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>


   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         Works similar to javaElementFilter definition with targetId as &quot;org.wst.sse.ui.OutlinePage&quot;.
         Target id can be changed for different content types to provide their own filters
      </documentation>
   </annotation>



   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2010 IBM Corporation and others.&lt;br&gt;
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 &lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
      </documentation>
   </annotation>

</schema>

Lines 579-584 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/contentoutline/ConfigurableContentOutlinePage.java (+1 lines)
579	}	579	}
580		580
581	fConfiguration = configuration;	581	fConfiguration = configuration;
		582	fConfiguration.setViewer(getTreeViewer());
582		583
583	if (getTreeViewer() != null && getControl() != null && !getControl().isDisposed()) {	584	if (getTreeViewer() != null && getControl() != null && !getControl().isDisposed()) {
584	// (re)set the providers	585	// (re)set the providers




/*******************************************************************************
	 * Copyright (c) 2010 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
	 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.filter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.window.Window;

	/**
	 * Action group to add the filter action to a view part's tool bar
	 * menu.
	 * <p>
	 * This class may be instantiated; it is not intended to be subclassed.
	 * </p>
	 *
	 * @noextend This class is not intended to be subclassed by clients.
	 */
	public class CustomFilterProcessor  {

		
		private static final String SEPARATOR= ",";  //$NON-NLS-1$
		private final String TAG_USER_DEFINED_PATTERNS_ENABLED= "userDefinedPatternsEnabled"; //$NON-NLS-1$
		private final String TAG_USER_DEFINED_PATTERNS= "userDefinedPatterns"; //$NON-NLS-1$
		
		
		private static class FilterItem {
			boolean enabled;
			boolean previouslyEnabled;
			OutlineFilterDescriptor descriptor;
			String id;

			private ViewerFilter filterInstance= null;

			public FilterItem(OutlineFilterDescriptor descriptor) {
				this.descriptor= descriptor;
				this.id= descriptor.getId();
				this.previouslyEnabled= false;
				this.enabled= descriptor.isEnabled();
			}

			public ViewerFilter getFilterInstance() {
				if (filterInstance == null) {
					filterInstance= descriptor.createViewerFilter();
				}
				return filterInstance;

			}
		}


		private final StructuredViewer fViewer;
		private final OutlineNamePatternFilter fPatternFilter;

		private boolean fUserDefinedPatternsEnabled;
		private String[] fUserDefinedPatterns;

		private String[] fPreviousPatterns;

		private final Map fFilterItems;


		
		private final String fTargetId;
		private IPreferenceStore fStore;
		

		/**
		 * Creates a new <code>CustomFilterAction</code>.
		 *
		 * @param store     the preference Store 
		 * @param ownerId	the id of this action group's owner
		 * @param viewer	the viewer to be filtered
		 */
		public CustomFilterProcessor(IPreferenceStore store,String ownerId, StructuredViewer viewer) {
			Assert.isNotNull(ownerId);
			Assert.isNotNull(viewer);
			fStore = store;
			fTargetId= ownerId;
			fViewer= viewer;
			fPatternFilter= new OutlineNamePatternFilter();

			fUserDefinedPatterns= new String[0];
			fUserDefinedPatternsEnabled= false;
			fPreviousPatterns= new String[0];

			fFilterItems= new HashMap();
			OutlineFilterDescriptor[] filterDescriptors= OutlineFilterDescriptor.getFilterDescriptors(fTargetId);
			for (int i= 0; i < filterDescriptors.length; i++) {
				FilterItem item= new FilterItem(filterDescriptors[i]);
				fFilterItems.put(item.id, item);
				
			}

			initializeWithViewDefaults();

			updateViewerFilters();
					
		}
		
		
		

		/*
		 * @see org.eclipse.jface.action.IContributionItem#isDynamic()
		 */
		public boolean isDynamic() {
			return true;
		}
		/**
		 * Returns a list of currently enabled filters. The filter
		 * is identified by its id.
		 * <p>
		 * This method is for internal use only and should not
		 * be called by clients outside of JDT/UI.
		 * </p>
		 *
		 * @return a list of currently enabled filters
		 *
		 * @noreference This method is not intended to be referenced by clients.
		 */
		public String[] internalGetEnabledFilterIds() {
			ArrayList enabledFilterIds= new ArrayList();
			for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
				FilterItem item= (FilterItem) iterator.next();
				if (item.enabled) {
					enabledFilterIds.add(item.id);
				}
			}
			return (String[])enabledFilterIds.toArray(new String[enabledFilterIds.size()]);
		}

		private void setEnabledFilterIds(String[] enabledIds) {
			// set all to false
			fUserDefinedPatternsEnabled= false;
			for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
				FilterItem item= (FilterItem) iterator.next();
				item.enabled= false;
			}
			// set enabled to true
			for (int i= 0; i < enabledIds.length; i++) {
				FilterItem item= (FilterItem) fFilterItems.get(enabledIds[i]);
				if (item != null) {
					item.enabled= true;
				}
				if (fPatternFilter.getClass().getName().equals(enabledIds[i]))
					fUserDefinedPatternsEnabled= true;
			}
		}

		private void setUserDefinedPatterns(String[] patterns) {
			fUserDefinedPatterns= patterns;
		}


		private boolean areUserDefinedPatternsEnabled() {
			return fUserDefinedPatternsEnabled;
		}

		private void setUserDefinedPatternsEnabled(boolean state) {
			fUserDefinedPatternsEnabled= state;
		}

				
		// ---------- viewer filter handling ----------

		private boolean updateViewerFilters() {
			ViewerFilter[] installedFilters= fViewer.getFilters();
			ArrayList viewerFilters= new ArrayList(installedFilters.length);
			
			HashSet patterns= new HashSet();

			boolean hasChange= false;
			boolean patternChange= false;

			for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
				FilterItem item= (FilterItem) iterator.next();
				if (item.descriptor.isCustomFilter()) {
					if (item.enabled != item.previouslyEnabled) {
						hasChange = true;
					}
					if (item.enabled){
						ViewerFilter filter= item.getFilterInstance(); // only create when changed
						if (filter != null) {
							viewerFilters.add(filter);
						}
					}
				} else if (item.descriptor.isPatternFilter()) {
					if (item.enabled) {
						patterns.add(item.descriptor.getPattern());
					}
					patternChange |= (item.enabled != item.previouslyEnabled);
				}
				item.previouslyEnabled= item.enabled;
			}

			if (areUserDefinedPatternsEnabled()) {
				for (int i= 0; i < fUserDefinedPatterns.length; i++) {
					patterns.add(fUserDefinedPatterns[i]);
				}
			}
			if (!patternChange) { // no pattern change so far, test if the user patterns made a difference
				patternChange= hasChanges(patterns, fPreviousPatterns);
			}

			fPreviousPatterns= (String[]) patterns.toArray(new String[patterns.size()]);
			if (patternChange) {
				fPatternFilter.setPatterns(fPreviousPatterns);
				if (patterns.isEmpty()) {
					viewerFilters.remove(fPatternFilter);
				} else if (!viewerFilters.contains(fPatternFilter)) {
					boolean contains = false;
					for (int i=0; i< viewerFilters.size();i++){
						if (viewerFilters.get(i) instanceof OutlineNamePatternFilter){
							OutlineNamePatternFilter filter = (OutlineNamePatternFilter)viewerFilters.get(i);
							String[] a1 =filter.getPatterns();
							String[] a2 =fPatternFilter.getPatterns();
							if (a1[0].equals(a2[0]))
								contains= true;
							else {
								viewerFilters.remove(i);
							}
							break;
						}
					}
					if (!contains)
						viewerFilters.add(fPatternFilter);
				}
				hasChange= true;
			}
			if (hasChange) {
				fViewer.setFilters((ViewerFilter[]) viewerFilters.toArray(new ViewerFilter[viewerFilters.size()])); // will refresh
			}
			return hasChange;
		}

		private boolean hasChanges(HashSet patterns, String[] oldPatterns) {
			HashSet copy= (HashSet) patterns.clone();
			for (int i= 0; i < oldPatterns.length; i++) {
				boolean found= copy.remove(oldPatterns[i]);
				if (!found)
					return true;
			}
			return !copy.isEmpty();
		}

		// ---------- view kind/defaults persistency ----------

		private void initializeWithViewDefaults() {
			// get default values for view
			
			
			fUserDefinedPatternsEnabled= fStore.getBoolean(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED));
			setUserDefinedPatterns(OutlineCustomFiltersDialog.convertFromString(fStore.getString(getPreferenceKey(TAG_USER_DEFINED_PATTERNS)), SEPARATOR));

			for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
				FilterItem item= (FilterItem) iterator.next();
				String id= item.id;
				// set default to value from plugin contributions (fixes https://bugs.eclipse.org/bugs/show_bug.cgi?id=73991 ):
				fStore.setDefault(id, item.descriptor.isEnabled());
				item.enabled= fStore.getBoolean(id);
			}
		
		}

		private void storeViewDefaults() {
			// get default values for view
			
			fStore.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED), fUserDefinedPatternsEnabled);
			fStore.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS), OutlineCustomFiltersDialog.convertToString(fUserDefinedPatterns ,SEPARATOR));

			boolean fFilterSelected = false;
			for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
				FilterItem item= (FilterItem) iterator.next();
				fStore.setValue(item.id, item.enabled);
				if (item.enabled)
					fFilterSelected = true;
			}

			fStore.setValue(fTargetId, fUserDefinedPatternsEnabled || fFilterSelected);
			
		}

		private String getPreferenceKey(String tag) {
			return "CustomFiltersActionGroup." + fTargetId + '.' + tag; //$NON-NLS-1$
		}

		
		public void openDialog() {
			OutlineCustomFiltersDialog dialog= new OutlineCustomFiltersDialog(
				fViewer.getControl().getShell(),
				fTargetId,
				areUserDefinedPatternsEnabled(),
				fUserDefinedPatterns,
				internalGetEnabledFilterIds());

			if (dialog.open() == Window.OK) {

				setEnabledFilterIds(dialog.getEnabledFilterIds());
				setUserDefinedPatternsEnabled(dialog.areUserDefinedPatternsEnabled());
				setUserDefinedPatterns(dialog.getUserDefinedPatterns());
				storeViewDefaults();

				updateViewerFilters();
			}
			else {
				storeViewDefaults();
			}
		}
	}





/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.filter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.SelectionDialog;
import org.eclipse.wst.sse.ui.internal.SSEUIPlugin;


public class OutlineCustomFiltersDialog extends SelectionDialog {

	private static final String SEPARATOR= ",";  //$NON-NLS-1$

	private String fViewId;
	private boolean fEnablePatterns;
	private String[] fPatterns;
	private String[] fEnabledFilterIds;

	private OutlineFilterDescriptor[] fBuiltInFilters;

	private CheckboxTableViewer fCheckBoxList;
	private Button fEnableUserDefinedPatterns;
	private Text fUserDefinedPatterns;

	private Stack fFilterDescriptorChangeHistory;


	/**
	 * Creates a dialog to customize Java element filters.
	 *
	 * @param shell the parent shell
	 * @param viewId the id of the view
	 * @param enablePatterns <code>true</code> if pattern filters are enabled
	 * @param patterns the filter patterns
	 * @param enabledFilterIds the Ids of the enabled filters
	 */
	public OutlineCustomFiltersDialog(
			Shell shell,
			String viewId,
			boolean enablePatterns,
			String[] patterns,
			String[] enabledFilterIds) {

		super(shell);
		Assert.isNotNull(viewId);
		Assert.isNotNull(patterns);
		Assert.isNotNull(enabledFilterIds);

		fViewId= viewId;
		fPatterns= patterns;
		fEnablePatterns= enablePatterns;
		fEnabledFilterIds= enabledFilterIds;

		fBuiltInFilters= OutlineFilterDescriptor.getFilterDescriptors(fViewId);
		fFilterDescriptorChangeHistory= new Stack();
	}
	public static final String CUSTOM_FILTERS_DIALOG= SSEUIPlugin.ID + "." + "open_custom_filters_dialog_context"; //$NON-NLS-1$
	protected void configureShell(Shell shell) {
		setTitle(OutlineFilterMessages.CustomFiltersDialog_title);
		setMessage(OutlineFilterMessages.CustomFiltersDialog_filterList_label);
		super.configureShell(shell);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(shell, CUSTOM_FILTERS_DIALOG);
	}

	/**
	 * Overrides method in Dialog
	 *
	 * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(Composite)
	 */
	protected Control createDialogArea(Composite parent) {
		initializeDialogUnits(parent);
		// create a composite with standard margins and spacing
		Composite composite= new Composite(parent, SWT.NONE);
		GridLayout layout= new GridLayout();
		layout.marginHeight= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		layout.marginWidth= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		layout.verticalSpacing= convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
		composite.setFont(parent.getFont());
		Composite group= composite;

		// Checkbox
		fEnableUserDefinedPatterns= new Button(group, SWT.CHECK);
		fEnableUserDefinedPatterns.setFocus();
		fEnableUserDefinedPatterns.setText(OutlineFilterMessages.CustomFiltersDialog_enableUserDefinedPattern);

		// Pattern	field
		fUserDefinedPatterns= new Text(group, SWT.SINGLE | SWT.BORDER);
		GridData  data= new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
		data.widthHint= convertWidthInCharsToPixels(59);
		fUserDefinedPatterns.setLayoutData(data);
		String patterns= convertToString(fPatterns, SEPARATOR);
		fUserDefinedPatterns.setText(patterns);
		SWTUtil.setAccessibilityText(fUserDefinedPatterns, OutlineFilterMessages.CustomFiltersDialog_name_filter_pattern_description);

		// Info text
		final Label info= new Label(group, SWT.LEFT);
		info.setText(OutlineFilterMessages.CustomFiltersDialog_patternInfo);

		// Enabling / disabling of pattern group
		fEnableUserDefinedPatterns.setSelection(fEnablePatterns);
		fUserDefinedPatterns.setEnabled(fEnablePatterns);
		info.setEnabled(fEnablePatterns);
		fEnableUserDefinedPatterns.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				boolean state= fEnableUserDefinedPatterns.getSelection();
				fUserDefinedPatterns.setEnabled(state);
				info.setEnabled(fEnableUserDefinedPatterns.getSelection());
				if (state)
					fUserDefinedPatterns.setFocus();
			}
		});

		// Filters provided by extension point
		if (fBuiltInFilters.length > 0)
			createCheckBoxList(group);

		applyDialogFont(parent);
		return parent;
	}

	private void createCheckBoxList(Composite parent) {
		// Filler
		new Label(parent, SWT.NONE);

		Label info= new Label(parent, SWT.LEFT);
		info.setText(OutlineFilterMessages.CustomFiltersDialog_filterList_label);

		fCheckBoxList= CheckboxTableViewer.newCheckList(parent, SWT.BORDER);
		GridData data= new GridData(GridData.FILL_BOTH);
		data.heightHint= fCheckBoxList.getTable().getItemHeight() * 10;
		fCheckBoxList.getTable().setLayoutData(data);

		fCheckBoxList.setLabelProvider(createLabelPrivder());
		fCheckBoxList.setContentProvider(new ArrayContentProvider());
		Arrays.sort(fBuiltInFilters);
		fCheckBoxList.setInput(fBuiltInFilters);
		setInitialSelections(getEnabledFilterDescriptors());

		List initialSelection= getInitialElementSelections();
		if (initialSelection != null && !initialSelection.isEmpty())
			checkInitialSelections();

		// Description
		info= new Label(parent, SWT.LEFT);
		info.setText(OutlineFilterMessages.CustomFiltersDialog_description_label);
		final Text description= new Text(parent, SWT.LEFT | SWT.WRAP | SWT.MULTI | SWT.READ_ONLY | SWT.BORDER | SWT.V_SCROLL);
		data = new GridData(GridData.FILL_HORIZONTAL);
		data.heightHint= convertHeightInCharsToPixels(3);
		description.setLayoutData(data);
		fCheckBoxList.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				ISelection selection= event.getSelection();
				if (selection instanceof IStructuredSelection) {
					Object selectedElement= ((IStructuredSelection)selection).getFirstElement();
					if (selectedElement instanceof OutlineFilterDescriptor)
						description.setText(((OutlineFilterDescriptor)selectedElement).getDescription());
				}
			}
		});
		fCheckBoxList.addCheckStateListener(new ICheckStateListener() {
			/*
			 * @see org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged(org.eclipse.jface.viewers.CheckStateChangedEvent)
			 */
			public void checkStateChanged(CheckStateChangedEvent event) {
				Object element= event.getElement();
				if (element instanceof OutlineFilterDescriptor) {
					// renew if already touched
					if (fFilterDescriptorChangeHistory.contains(element))
						fFilterDescriptorChangeHistory.remove(element);
					fFilterDescriptorChangeHistory.push(element);
				}
			}});

		addSelectionButtons(parent);
	}

	private void addSelectionButtons(Composite composite) {
		Composite buttonComposite= new Composite(composite, SWT.RIGHT);
		GridLayout layout= new GridLayout();
		layout.numColumns= 2;
		buttonComposite.setLayout(layout);
		GridData data= new GridData(GridData.HORIZONTAL_ALIGN_END | GridData.GRAB_HORIZONTAL);
		data.grabExcessHorizontalSpace= true;
		composite.setData(data);

		// Select All button
		String label= OutlineFilterMessages.CustomFiltersDialog_SelectAllButton_label;
		Button selectButton= createButton(buttonComposite, IDialogConstants.SELECT_ALL_ID, label, false);
		SWTUtil.setButtonDimensionHint(selectButton);
		SelectionListener listener= new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				fCheckBoxList.setAllChecked(true);
				fFilterDescriptorChangeHistory.clear();
				for (int i= 0; i < fBuiltInFilters.length; i++)
					fFilterDescriptorChangeHistory.push(fBuiltInFilters[i]);
			}
		};
		selectButton.addSelectionListener(listener);

		// De-select All button
		label= OutlineFilterMessages.CustomFiltersDialog_DeselectAllButton_label;
		Button deselectButton= createButton(buttonComposite, IDialogConstants.DESELECT_ALL_ID, label, false);
		SWTUtil.setButtonDimensionHint(deselectButton);
		listener= new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				fCheckBoxList.setAllChecked(false);
				fFilterDescriptorChangeHistory.clear();
				for (int i= 0; i < fBuiltInFilters.length; i++)
					fFilterDescriptorChangeHistory.push(fBuiltInFilters[i]);
			}
		};
		deselectButton.addSelectionListener(listener);
	}

	private void checkInitialSelections() {
		Iterator itemsToCheck= getInitialElementSelections().iterator();
		while (itemsToCheck.hasNext())
			fCheckBoxList.setChecked(itemsToCheck.next(),true);
	}

	protected void okPressed() {
		if (fBuiltInFilters != null) {
			ArrayList result= new ArrayList();
			for (int i= 0; i < fBuiltInFilters.length; ++i) {
				if (fCheckBoxList.getChecked(fBuiltInFilters[i]))
					result.add(fBuiltInFilters[i]);
			}
			setResult(result);
		}
		super.okPressed();
	}

	private ILabelProvider createLabelPrivder() {
		return
			new LabelProvider() {
				public Image getImage(Object element) {
					return null;
				}
				public String getText(Object element) {
					if (element instanceof OutlineFilterDescriptor)
						return ((OutlineFilterDescriptor)element).getName();
					else
						return null;
				}
			};
	}

	// ---------- result handling ----------

	protected void setResult(List newResult) {
		super.setResult(newResult);
		if (fUserDefinedPatterns.getText().length() > 0) {
			fEnablePatterns= fEnableUserDefinedPatterns.getSelection();
			fPatterns= convertFromString(fUserDefinedPatterns.getText(), SEPARATOR);
		} else {
			fEnablePatterns= false;
			fPatterns= new String[0];
		}
	}


	/**
	 * @return the patterns which have been entered by the user
	 */
	public String[] getUserDefinedPatterns() {
		return fPatterns;
	}

	/**
	 * @return the Ids of the enabled built-in filters
	 */
	public String[] getEnabledFilterIds() {
		Object[] result= getResult();
		Set enabledIds= new HashSet(result.length);
		for (int i= 0; i < result.length; i++)
			enabledIds.add(((OutlineFilterDescriptor)result[i]).getId());
		return (String[]) enabledIds.toArray(new String[enabledIds.size()]);
	}

	/**
	 * @return <code>true</code> if the user-defined patterns are disabled
	 */
	public boolean areUserDefinedPatternsEnabled() {
		return fEnablePatterns;
	}

	/**
	 * @return a stack with the filter descriptor check history
	 */
	public Stack getFilterDescriptorChangeHistory() {
		return fFilterDescriptorChangeHistory;
	}

	private OutlineFilterDescriptor[] getEnabledFilterDescriptors() {
		OutlineFilterDescriptor[] filterDescs= fBuiltInFilters;
		List result= new ArrayList(filterDescs.length);
		List enabledFilterIds= Arrays.asList(fEnabledFilterIds);
		for (int i= 0; i < filterDescs.length; i++) {
			String id= filterDescs[i].getId();
			if (enabledFilterIds.contains(id))
				result.add(filterDescs[i]);
		}
		return (OutlineFilterDescriptor[])result.toArray(new OutlineFilterDescriptor[result.size()]);
	}


	public static String[] convertFromString(String patterns, String separator) {
		StringTokenizer tokenizer= new StringTokenizer(patterns, separator, true);
		int tokenCount= tokenizer.countTokens();
		List result= new ArrayList(tokenCount);
		boolean escape= false;
		boolean append= false;
		while (tokenizer.hasMoreTokens()) {
			String token= tokenizer.nextToken().trim();
			if (separator.equals(token)) {
				if (!escape)
					escape= true;
				else {
					addPattern(result, separator);
					append= true;
				}
			} else  {
				if (!append)
 					result.add(token);
				else
					addPattern(result, token);
				append= false;
				escape= false;
			}
		}
		return (String[])result.toArray(new String[result.size()]);
	}

	private static void addPattern(List list, String pattern) {
		if (list.isEmpty())
			list.add(pattern);
		else {
			int index= list.size() - 1;
			list.set(index, ((String)list.get(index)) + pattern);
		}
	}

	public static String convertToString(String[] patterns, String separator) {
		int length= patterns.length;
		StringBuffer strBuf= new StringBuffer();
		if (length > 0)
			strBuf.append(escapeSeparator(patterns[0], separator));
		else
			return ""; //$NON-NLS-1$
		int i= 1;
		while (i < length) {
			strBuf.append(separator);
			strBuf.append(" "); //$NON-NLS-1$
			strBuf.append(escapeSeparator(patterns[i++], separator));
		}
		return strBuf.toString();
	}

	private static String escapeSeparator(String pattern, String separator) {
		int length= pattern.length();
		StringBuffer buf= new StringBuffer(length);
		for (int i= 0; i < length; i++) {
			char ch= pattern.charAt(i);
			if (separator.equals(String.valueOf(ch)))
				buf.append(ch);
			buf.append(ch);
		}
		return buf.toString();

	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.filter;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import com.ibm.icu.text.Collator;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;

import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.ui.IPluginContribution;
import org.eclipse.ui.activities.WorkbenchActivityHelper;
import org.eclipse.wst.sse.ui.internal.SSEUIPlugin;



/**
 * Represents a custom filter which is provided by the
 * "org.eclipse.sse.ui.outlineFilters" extension point.
 *
 */
public class OutlineFilterDescriptor implements Comparable, IPluginContribution {

	private static String PATTERN_FILTER_ID_PREFIX= "_patternFilterId_"; //$NON-NLS-1$


	private static final String EXTENSION_POINT_NAME= "outlineFilters"; //$NON-NLS-1$

	private static final String FILTER_TAG= "filter"; //$NON-NLS-1$

	private static final String PATTERN_ATTRIBUTE= "pattern"; //$NON-NLS-1$
	private static final String ID_ATTRIBUTE= "id"; //$NON-NLS-1$
	private static final String TARGET_ID_ATTRIBUTE= "targetId"; //$NON-NLS-1$
	private static final String CLASS_ATTRIBUTE= "class"; //$NON-NLS-1$
	private static final String NAME_ATTRIBUTE= "name"; //$NON-NLS-1$
	private static final String ENABLED_ATTRIBUTE= "enabled"; //$NON-NLS-1$
	private static final String DESCRIPTION_ATTRIBUTE= "description"; //$NON-NLS-1$
	
	private static OutlineFilterDescriptor[] fgFilterDescriptors;


	private IConfigurationElement fElement;

	/**
	 * Returns all contributed Java element filters.
	 * @return all contributed Java element filters
	 */
	public static OutlineFilterDescriptor[] getFilterDescriptors() {
		if (fgFilterDescriptors == null) {
			IExtensionRegistry registry= Platform.getExtensionRegistry();
			IConfigurationElement[] elements= registry.getConfigurationElementsFor(SSEUIPlugin.ID, EXTENSION_POINT_NAME);
			fgFilterDescriptors= createFilterDescriptors(elements);
		}
		return fgFilterDescriptors;
	}
	/**
	 * Returns all Java element filters which
	 * are contributed to the given view.
	 * @param targetId the target id
	 * @return all contributed Java element filters for the given view
	 */
	public static OutlineFilterDescriptor[] getFilterDescriptors(String targetId) {
		OutlineFilterDescriptor[] filterDescs= OutlineFilterDescriptor.getFilterDescriptors();
		List result= new ArrayList(filterDescs.length);
		for (int i= 0; i < filterDescs.length; i++) {
			String tid= filterDescs[i].getTargetId();
			if (WorkbenchActivityHelper.filterItem(filterDescs[i]))
				continue;
			if (tid == null || tid.equals(targetId))
				result.add(filterDescs[i]);
		}
		return (OutlineFilterDescriptor[])result.toArray(new OutlineFilterDescriptor[result.size()]);
	}

	/**
	 * Creates a new filter descriptor for the given configuration element.
	 * @param element configuration element
	 */
	private OutlineFilterDescriptor(IConfigurationElement element) {
		fElement= element;
		// it is either a pattern filter or a custom filter
		Assert.isTrue(isPatternFilter() ^ isCustomFilter(), "An extension for extension-point org.eclipse.sse.ui.outlineFilters does not specify a correct filter"); //$NON-NLS-1$
		Assert.isNotNull(getId(), "An extension for extension-point org.eclipse.sse.ui.outlineFilters does not provide a valid ID"); //$NON-NLS-1$
		Assert.isNotNull(getName(), "An extension for extension-point org.eclipse.sse.ui.outlineFilters does not provide a valid name"); //$NON-NLS-1$
	}

	/**
	 * Creates a new <code>ViewerFilter</code>.
	 * This method is only valid for viewer filters.
	 * @return a new <code>ViewerFilter</code>
	 */
	public ViewerFilter createViewerFilter() {
		if (!isCustomFilter())
			return null;

		final ViewerFilter[] result= new ViewerFilter[1];
		String message = OutlineFilterMessages.FilterDescriptor_filterCreationError_message;
		ISafeRunnable code= new SafeRunnable(message) {
			/*
			 * @see org.eclipse.core.runtime.ISafeRunnable#run()
			 */
			public void run() throws Exception {
				result[0]= (ViewerFilter)fElement.createExecutableExtension(CLASS_ATTRIBUTE);
			}

		};
		SafeRunner.run(code);
		return result[0];
	}

	//---- XML Attribute accessors ---------------------------------------------

	/**
	 * Returns the filter's id.
	 * <p>
	 * This attribute is mandatory for custom filters.
	 * The ID for pattern filters is
	 * PATTERN_FILTER_ID_PREFIX plus the pattern itself.
	 * </p>
	 * @return the filter id
	 */
	public String getId() {
		if (isPatternFilter()) {
			String targetId= getTargetId();
			if (targetId == null)
				return PATTERN_FILTER_ID_PREFIX + getPattern();
			else
				return targetId + PATTERN_FILTER_ID_PREFIX + getPattern();
		} else
			return fElement.getAttribute(ID_ATTRIBUTE);
	}

	/**
	 * Returns the filter's name.
	 * <p>
	 * If the name of a pattern filter is missing
	 * then the pattern is used as its name.
	 * </p>
	 * @return the filter's name
	 */
	public String getName() {
		String name= fElement.getAttribute(NAME_ATTRIBUTE);
		if (name == null && isPatternFilter())
			name= getPattern();
		return name;
	}

	/**
	 * Returns the filter's pattern.
	 *
	 * @return the pattern string or <code>null</code> if it's not a pattern filter
	 */
	public String getPattern() {
		return fElement.getAttribute(PATTERN_ATTRIBUTE);
	}

	/**
	 * Returns the filter's viewId.
	 *
	 * @return the view ID or <code>null</code> if the filter is for all views
	 */
	public String getTargetId() {
		String tid= fElement.getAttribute(TARGET_ID_ATTRIBUTE);

		if (tid != null)
			return tid;

		// Backwards compatibility code
		return null;

	}

	/**
	 * Returns the filter's description.
	 *
	 * @return the description or <code>null</code> if no description is provided
	 */
	public String getDescription() {
		String description= fElement.getAttribute(DESCRIPTION_ATTRIBUTE);
		if (description == null)
			description= ""; //$NON-NLS-1$
		return description;
	}

	/**
	 * @return <code>true</code> if this filter is a custom filter.
	 */
	public boolean isPatternFilter() {
		return getPattern() != null;
	}

	/**
	 * @return <code>true</code> if this filter is a pattern filter.
	 */
	public boolean isCustomFilter() {
		return fElement.getAttribute(CLASS_ATTRIBUTE) != null;
	}

	/**
	 * Returns <code>true</code> if the filter
	 * is initially enabled.
	 *
	 * This attribute is optional and defaults to <code>true</code>.
	 * @return returns <code>true</code> if the filter is initially enabled
	 */
	public boolean isEnabled() {
		String strVal= fElement.getAttribute(ENABLED_ATTRIBUTE);
		return strVal == null || Boolean.valueOf(strVal).booleanValue();
	}

	/*
	 * Implements a method from IComparable
	 */
	public int compareTo(Object o) {
		if (o instanceof OutlineFilterDescriptor)
			return Collator.getInstance().compare(getName(), ((OutlineFilterDescriptor)o).getName());
		else
			return Integer.MIN_VALUE;
	}

	//---- initialization ---------------------------------------------------

	/**
	 * Creates the filter descriptors.
	 * @param elements the configuration elements
	 * @return new filter descriptors
	 */
	private static OutlineFilterDescriptor[] createFilterDescriptors(IConfigurationElement[] elements) {
		List result= new ArrayList(5);
		Set descIds= new HashSet(5);
		for (int i= 0; i < elements.length; i++) {
			final IConfigurationElement element= elements[i];
			if (FILTER_TAG.equals(element.getName())) {

				final OutlineFilterDescriptor[] desc= new OutlineFilterDescriptor[1];
				SafeRunner.run(new SafeRunnable(OutlineFilterMessages.FilterDescriptor_filterDescriptionCreationError_message) {
					public void run() throws Exception {
						desc[0]= new OutlineFilterDescriptor(element);
					}
				});

				if (desc[0] != null && !descIds.contains(desc[0].getId())) {
					result.add(desc[0]);
					descIds.add(desc[0].getId());
				}
			}
		}
		return (OutlineFilterDescriptor[])result.toArray(new OutlineFilterDescriptor[result.size()]);
	}

	public String getLocalId() {
		return fElement.getAttribute(ID_ATTRIBUTE);
	}

    public String getPluginId() {
        return fElement.getContributor().getName();
    }
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.filter;

import org.eclipse.osgi.util.NLS;

public final class OutlineFilterMessages extends NLS {

	private static final String BUNDLE_NAME= "org.eclipse.wst.sse.ui.internal.filter.OutlineFilterMessages";//$NON-NLS-1$

	private OutlineFilterMessages() {
		// Do not instantiate
	}

	public static String CustomFiltersDialog_title;
	public static String CustomFiltersDialog_patternInfo;
	public static String CustomFiltersDialog_enableUserDefinedPattern;
	public static String CustomFiltersDialog_filterList_label;
	public static String CustomFiltersDialog_description_label;
	public static String CustomFiltersDialog_SelectAllButton_label;
	public static String CustomFiltersDialog_DeselectAllButton_label;
	public static String CustomFiltersDialog_name_filter_pattern_description;
	public static String OpenCustomFiltersDialogAction_text;
	public static String FilterDescriptor_filterDescriptionCreationError_message;
	public static String FilterDescriptor_filterCreationError_message;

	static {
		NLS.initializeMessages(BUNDLE_NAME, OutlineFilterMessages.class);
	}
}




###############################################################################
# Copyright (c) 2010 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
###############################################################################

CustomFiltersDialog_title= Java Element Filters
CustomFiltersDialog_patternInfo= The patterns are separated by comma, where\n* = any string, ? = any character, ,, = ,
CustomFiltersDialog_enableUserDefinedPattern= &Name filter patterns (matching names will be hidden):
CustomFiltersDialog_filterList_label= S&elect the elements to exclude from the view:
CustomFiltersDialog_description_label= Filter description:
CustomFiltersDialog_SelectAllButton_label= &Select All
CustomFiltersDialog_DeselectAllButton_label= &Deselect All
CustomFiltersDialog_name_filter_pattern_description=Name filter patterns. The patterns are separated by comma, where star is any string

OpenCustomFiltersDialogAction_text= &Filters...

FilterDescriptor_filterDescriptionCreationError_message= One of the extensions for extension-point org.eclipse.wst.sse.ui.outlineFilters is incorrect.
FilterDescriptor_filterCreationError_message= The org.eclipse.wst.sse.ui.outlineFilters plug-in extension "{0}" specifies a viewer filter class which does not exist.




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.filter;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.w3c.dom.Node;

/**
 * The NamePatternFilter selects the elements which
 * match the given string patterns.
 * <p>
 * The following characters have special meaning:
 *   ? => any character
 *   * => any string
 * </p>
 *
 */
public class OutlineNamePatternFilter extends ViewerFilter {
	private String[] fPatterns;
	private StringMatcher[] fMatchers;


	/**
	 * Gets the patterns for the receiver.
	 * @return returns the patterns to be filtered for
	 */
	public String[] getPatterns() {
		return fPatterns;
	}


	/* (non-Javadoc)
	 * Method declared on ViewerFilter.
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if (getPatterns().length == 0) {
			return true;
		}
		String matchName= null;
		if (element instanceof Node){
			matchName =((Node)element).getNodeName();
		}
		if (matchName != null && matchName.length() > 0) {
			String[] fPatterns = getPatterns();
			for (int i = 0; i < fPatterns.length; i++) {
				if (new StringMatcher(fPatterns[i], true, false).match(matchName))
					return false;
			}
			return true;
		}
		return true;
	}

	/**
	 * Sets the patterns to filter out for the receiver.
	 * <p>
	 * The following characters have special meaning:
	 *   ? => any character
	 *   * => any string
	 * </p>
	 * @param newPatterns the new patterns
	 */
	public void setPatterns(String[] newPatterns) {
		fPatterns = newPatterns;
		fMatchers = new StringMatcher[newPatterns.length];
		for (int i = 0; i < newPatterns.length; i++) {
			//Reset the matchers to prevent constructor overhead
			fMatchers[i]= new StringMatcher(newPatterns[i], true, false);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.filter;

import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Caret;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Widget;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.layout.PixelConverter;
import org.eclipse.jface.resource.JFaceResources;


/**
 * Utility class to simplify access to some SWT resources.
 */
public class SWTUtil {


	public static final int COMBO_VISIBLE_ITEM_COUNT= 30;

	/**
	 * Returns the standard display to be used. The method first checks, if
	 * the thread calling this method has an associated display. If so, this
	 * display is returned. Otherwise the method returns the default display.
	 * @return returns the standard display to be used
	 */
	public static Display getStandardDisplay() {
		Display display;
		display= Display.getCurrent();
		if (display == null)
			display= Display.getDefault();
		return display;
	}

	/**
	 * Returns the shell for the given widget. If the widget doesn't represent
	 * a SWT object that manage a shell, <code>null</code> is returned.
	 * @param widget the widget
	 *
	 * @return the shell for the given widget
	 */
	public static Shell getShell(Widget widget) {
		if (widget instanceof Control)
			return ((Control)widget).getShell();
		if (widget instanceof Caret)
			return ((Caret)widget).getParent().getShell();
		if (widget instanceof DragSource)
			return ((DragSource)widget).getControl().getShell();
		if (widget instanceof DropTarget)
			return ((DropTarget)widget).getControl().getShell();
		if (widget instanceof Menu)
			return ((Menu)widget).getParent().getShell();
		if (widget instanceof ScrollBar)
			return ((ScrollBar)widget).getParent().getShell();

		return null;
	}


	/**
	 * Returns a width hint for a button control.
	 * @param button the button
	 * @return the width hint
	 */
	public static int getButtonWidthHint(Button button) {
		button.setFont(JFaceResources.getDialogFont());
		PixelConverter converter= new PixelConverter(button);
		int widthHint= converter.convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
		return Math.max(widthHint, button.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);
	}

	/**
	 * Sets width and height hint for the button control.
	 * <b>Note:</b> This is a NOP if the button's layout data is not
	 * an instance of <code>GridData</code>.
	 *
	 * @param button	the button for which to set the dimension hint
	 */
	public static void setButtonDimensionHint(Button button) {
		Assert.isNotNull(button);
		Object gd= button.getLayoutData();
		if (gd instanceof GridData) {
			((GridData)gd).widthHint= getButtonWidthHint(button);
			((GridData)gd).horizontalAlignment = GridData.FILL;
		}
	}

	public static int getTableHeightHint(Table table, int rows) {
		if (table.getFont().equals(JFaceResources.getDefaultFont()))
			table.setFont(JFaceResources.getDialogFont());
		int result= table.getItemHeight() * rows + table.getHeaderHeight();
		if (table.getLinesVisible())
			result+= table.getGridLineWidth() * (rows - 1);
		return result;
	}

	/**
	 * Adds an accessibility listener returning the given fixed name.
	 *
	 * @param control the control to add the accessibility support to
	 * @param text the name
	 */
	public static void setAccessibilityText(Control control, final String text) {
		control.getAccessible().addAccessibleListener(new AccessibleAdapter() {
			public void getName(AccessibleEvent e) {
				e.result= text;
			}
		});
	}

	/**
	 *
	 * @param combo the combo
	 *
	 * @see Combo#setVisibleItemCount(int)
	 * @see #COMBO_VISIBLE_ITEM_COUNT
	 *
	 */
	public static void setDefaultVisibleItemCount(Combo combo) {
		combo.setVisibleItemCount(COMBO_VISIBLE_ITEM_COUNT);
	}

	public static GridLayout newLayoutNoMargins(int columns) {
		GridLayout layout= new GridLayout(columns, false);
		layout.marginWidth= 0;
		layout.marginHeight= 0;
		return layout;
	}


}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.filter;

import java.util.Vector;

/**
 * A string pattern matcher. Supports '*' and '?' wildcards.
 */
public class StringMatcher {
	protected String fPattern;
	protected int fLength; // pattern length
	protected boolean fIgnoreWildCards;
	protected boolean fIgnoreCase;
	protected boolean fHasLeadingStar;
	protected boolean fHasTrailingStar;
	protected String fSegments[]; //the given pattern is split into * separated segments

	/* boundary value beyond which we don't need to search in the text */
	protected int fBound= 0;


	protected static final char fSingleWildCard= '\u0000';

	public static class Position {
		int start; //inclusive
		int end; //exclusive
		public Position(int start, int end) {
			this.start= start;
			this.end= end;
		}
		public int getStart() {
			return start;
		}
		public int getEnd() {
			return end;
		}
	}
	/**
	 * StringMatcher constructor takes in a String object that is a simple
	 * pattern. The pattern may contain '*' for 0 and many characters and
	 * '?' for exactly one character.
	 *
	 * Literal '*' and '?' characters must be escaped in the pattern
	 * e.g., "\*" means literal "*", etc.
	 *
	 * Escaping any other character (including the escape character itself),
	 * just results in that character in the pattern.
	 * e.g., "\a" means "a" and "\\" means "\"
	 *
	 * If invoking the StringMatcher with string literals in Java, don't forget
	 * escape characters are represented by "\\".
	 *
	 * @param pattern the pattern to match text against
	 * @param ignoreCase if true, case is ignored
	 * @param ignoreWildCards if true, wild cards and their escape sequences are ignored
	 * 		  (everything is taken literally).
	 */
	public StringMatcher(String pattern, boolean ignoreCase, boolean ignoreWildCards) {
		if (pattern == null)
			throw new IllegalArgumentException();
		fIgnoreCase= ignoreCase;
		fIgnoreWildCards= ignoreWildCards;
		fPattern= pattern;
		fLength= pattern.length();

		if (fIgnoreWildCards) {
			parseNoWildCards();
		} else {
			parseWildCards();
		}
	}
	/**
	 * Find the first occurrence of the pattern between <code>start</code)(inclusive)
	 * and <code>end</code>(exclusive).
	 * @param text the String object to search in
	 * @param start the starting index of the search range, inclusive
	 * @param end the ending index of the search range, exclusive
	 * @return an <code>StringMatcher.Position</code> object that keeps the starting
	 * (inclusive) and ending positions (exclusive) of the first occurrence of the
	 * pattern in the specified range of the text; return null if not found or subtext
	 * is empty (start==end). A pair of zeros is returned if pattern is empty string
	 * Note that for pattern like "*abc*" with leading and trailing stars, position of "abc"
	 * is returned. For a pattern like"*??*" in text "abcdf", (1,3) is returned
	 */
	public StringMatcher.Position find(String text, int start, int end) {
		if (text == null)
			throw new IllegalArgumentException();

		int tlen= text.length();
		if (start < 0)
			start= 0;
		if (end > tlen)
			end= tlen;
		if (end < 0 ||start >= end )
			return null;
		if (fLength == 0)
			return new Position(start, start);
		if (fIgnoreWildCards) {
			int x= posIn(text, start, end);
			if (x < 0)
				return null;
			return new Position(x, x+fLength);
		}

		int segCount= fSegments.length;
		if (segCount == 0)//pattern contains only '*'(s)
			return new Position (start, end);

		int curPos= start;
		int matchStart= -1;
		int i;
		for (i= 0; i < segCount && curPos < end; ++i) {
			String current= fSegments[i];
			int nextMatch= regExpPosIn(text, curPos, end, current);
			if (nextMatch < 0 )
				return null;
			if(i == 0)
				matchStart= nextMatch;
			curPos= nextMatch + current.length();
		}
		if (i < segCount)
			return null;
		return new Position(matchStart, curPos);
	}
	/**
	 * match the given <code>text</code> with the pattern
	 * @return true if matched eitherwise false
	 * @param text a String object
	 */
	public boolean match(String text) {
		return match(text, 0, text.length());
	}
	/**
	 * Given the starting (inclusive) and the ending (exclusive) positions in the
	 * <code>text</code>, determine if the given substring matches with aPattern
	 * @return true if the specified portion of the text matches the pattern
	 * @param text a String object that contains the substring to match
	 * @param start marks the starting position (inclusive) of the substring
	 * @param end marks the ending index (exclusive) of the substring
	 */
	public boolean match(String text, int start, int end) {
		if (null == text)
			throw new IllegalArgumentException();

		if (start > end)
			return false;

		if (fIgnoreWildCards)
			return (end - start == fLength) && fPattern.regionMatches(fIgnoreCase, 0, text, start, fLength);
		int segCount= fSegments.length;
		if (segCount == 0 && (fHasLeadingStar || fHasTrailingStar))  // pattern contains only '*'(s)
			return true;
		if (start == end)
			return fLength == 0;
		if (fLength == 0)
			return start == end;

		int tlen= text.length();
		if (start < 0)
			start= 0;
		if (end > tlen)
			end= tlen;

		int tCurPos= start;
		int bound= end - fBound;
		if ( bound < 0)
			return false;
		int i=0;
		String current= fSegments[i];
		int segLength= current.length();

		/* process first segment */
		if (!fHasLeadingStar){
			if(!regExpRegionMatches(text, start, current, 0, segLength)) {
				return false;
			} else {
				++i;
				tCurPos= tCurPos + segLength;
			}
		}
		if ((fSegments.length == 1) && (!fHasLeadingStar) && (!fHasTrailingStar)) {
			// only one segment to match, no wildcards specified
			return tCurPos == end;
		}
		/* process middle segments */
		while (i < segCount) {
			current= fSegments[i];
			int currentMatch;
			int k= current.indexOf(fSingleWildCard);
			if (k < 0) {
				currentMatch= textPosIn(text, tCurPos, end, current);
				if (currentMatch < 0)
					return false;
			} else {
				currentMatch= regExpPosIn(text, tCurPos, end, current);
				if (currentMatch < 0)
					return false;
			}
			tCurPos= currentMatch + current.length();
			i++;
		}

		/* process final segment */
		if (!fHasTrailingStar && tCurPos != end) {
			int clen= current.length();
			return regExpRegionMatches(text, end - clen, current, 0, clen);
		}
		return i == segCount ;
	}

	/**
	 * This method parses the given pattern into segments seperated by wildcard '*' characters.
	 * Since wildcards are not being used in this case, the pattern consists of a single segment.
	 */
	private void parseNoWildCards() {
		fSegments= new String[1];
		fSegments[0]= fPattern;
		fBound= fLength;
	}
	/**
	 * Parses the given pattern into segments seperated by wildcard '*' characters.
	 */
	private void parseWildCards() {
		if(fPattern.startsWith("*"))//$NON-NLS-1$
			fHasLeadingStar= true;
		if(fPattern.endsWith("*")) {//$NON-NLS-1$
			/* make sure it's not an escaped wildcard */
			if (fLength > 1 && fPattern.charAt(fLength - 2) != '\\') {
				fHasTrailingStar= true;
			}
		}

		Vector temp= new Vector();

		int pos= 0;
		StringBuffer buf= new StringBuffer();
		while (pos < fLength) {
			char c= fPattern.charAt(pos++);
			switch (c) {
				case '\\':
					if (pos >= fLength) {
						buf.append(c);
					} else {
						char next= fPattern.charAt(pos++);
						/* if it's an escape sequence */
						if (next == '*' || next == '?' || next == '\\') {
							buf.append(next);
						} else {
							/* not an escape sequence, just insert literally */
							buf.append(c);
							buf.append(next);
						}
					}
				break;
				case '*':
					if (buf.length() > 0) {
						/* new segment */
						temp.addElement(buf.toString());
						fBound += buf.length();
						buf.setLength(0);
					}
				break;
				case '?':
					/* append special character representing single match wildcard */
					buf.append(fSingleWildCard);
				break;
				default:
					buf.append(c);
			}
		}

		/* add last buffer to segment list */
		if (buf.length() > 0) {
			temp.addElement(buf.toString());
			fBound += buf.length();
		}

		fSegments= new String[temp.size()];
		temp.copyInto(fSegments);
	}
	/**
	 * @param text a string which contains no wildcard
	 * @param start the starting index in the text for search, inclusive
	 * @param end the stopping point of search, exclusive
	 * @return the starting index in the text of the pattern , or -1 if not found
	 */
	protected int posIn(String text, int start, int end) {//no wild card in pattern
		int max= end - fLength;

		if (!fIgnoreCase) {
			int i= text.indexOf(fPattern, start);
			if (i == -1 || i > max)
				return -1;
			return i;
		}

		for (int i= start; i <= max; ++i) {
			if (text.regionMatches(true, i, fPattern, 0, fLength))
				return i;
		}

		return -1;
	}
	/**
	 * @param text a simple regular expression that may only contain '?'(s)
	 * @param start the starting index in the text for search, inclusive
	 * @param end the stopping point of search, exclusive
	 * @param p a simple regular expression that may contains '?'
	 * @return the starting index in the text of the pattern , or -1 if not found
	 */
	protected int regExpPosIn(String text, int start, int end, String p) {
		int plen= p.length();

		int max= end - plen;
		for (int i= start; i <= max; ++i) {
			if (regExpRegionMatches(text, i, p, 0, plen))
				return i;
		}
		return -1;
	}


	protected boolean regExpRegionMatches(String text, int tStart, String p, int pStart, int plen) {
		while (plen-- > 0) {
			char tchar= text.charAt(tStart++);
			char pchar= p.charAt(pStart++);

			/* process wild cards */
			if (!fIgnoreWildCards) {
				/* skip single wild cards */
				if (pchar == fSingleWildCard) {
					continue;
				}
			}
			if (pchar == tchar)
				continue;
			if (fIgnoreCase) {
				if (Character.toUpperCase(tchar) == Character.toUpperCase(pchar))
					continue;
				// comparing after converting to upper case doesn't handle all cases;
				// also compare after converting to lower case
				if (Character.toLowerCase(tchar) == Character.toLowerCase(pchar))
					continue;
			}
			return false;
		}
		return true;
	}
	/**
	 * @param text the string to match
	 * @param start the starting index in the text for search, inclusive
	 * @param end the stopping point of search, exclusive
	 * @param p a string that has no wildcard
	 * @return the starting index in the text of the pattern , or -1 if not found
	 */
	protected int textPosIn(String text, int start, int end, String p) {

		int plen= p.length();
		int max= end - plen;

		if (!fIgnoreCase) {
			int i= text.indexOf(p, start);
			if (i == -1 || i > max)
				return -1;
			return i;
		}

		for (int i= start; i <= max; ++i) {
			if (text.regionMatches(true, i, p, 0, plen))
				return i;
		}

		return -1;
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.handlers;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
import org.eclipse.wst.sse.ui.internal.contentoutline.ConfigurableContentOutlinePage;

public class CustomFilterHandler extends AbstractHandler {
	public Object execute(ExecutionEvent event) throws ExecutionException {

		IEditorPart editor = HandlerUtil.getActiveEditor(event);
		ConfigurableContentOutlinePage page = (ConfigurableContentOutlinePage) editor.getAdapter(IContentOutlinePage.class);
		if (page != null) {
			page.getConfiguration().handleCustomFilter();
		}
		return null;
	}
	
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.handlers;

import org.eclipse.core.expressions.PropertyTester;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
import org.eclipse.wst.sse.ui.internal.contentoutline.ConfigurableContentOutlinePage;

public class CustomFilterPropertyTester extends PropertyTester {
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.expressions.IPropertyTester#test(java.lang.Object,
	 *      java.lang.String, java.lang.Object[], java.lang.Object)
	 */
	public boolean test(Object receiver, String property, Object[] args,
			Object expectedValue) {
		if (receiver instanceof IEditorPart){
			IEditorPart editor = (IEditorPart)receiver;
			Object page = editor.getAdapter(IContentOutlinePage.class);
			if (page instanceof ConfigurableContentOutlinePage) {
				Boolean val = (Boolean)expectedValue;
				return val.booleanValue();
			}
		}
		return false;
	}
	
}

Lines 32-37 Link Here

(-)src/org/eclipse/wst/sse/ui/views/contentoutline/ContentOutlineConfiguration.java (+18 lines)
32	import org.eclipse.wst.sse.ui.internal.contentoutline.PropertyChangeUpdateActionContributionItem;	32	import org.eclipse.wst.sse.ui.internal.contentoutline.PropertyChangeUpdateActionContributionItem;
33	import org.eclipse.wst.sse.ui.internal.editor.EditorPluginImageHelper;	33	import org.eclipse.wst.sse.ui.internal.editor.EditorPluginImageHelper;
34	import org.eclipse.wst.sse.ui.internal.editor.EditorPluginImages;	34	import org.eclipse.wst.sse.ui.internal.editor.EditorPluginImages;
		35	import org.eclipse.wst.sse.ui.internal.filter.CustomFilterProcessor;
35		36
36	/**	37	/**
37	* Basic Configuration class for Outline Pages	38	* Basic Configuration class for Outline Pages
Lines 39-44 Link Here
39	* @since 1.0	40	* @since 1.0
40	*/	41	*/
41	public abstract class ContentOutlineConfiguration {	42	public abstract class ContentOutlineConfiguration {
		43
		44	private TreeViewer fTreeViewer;
42	/**	45	/**
43	* Add a collapse action to help with navigation.	46	* Add a collapse action to help with navigation.
44	*/	47	*/
Lines 86-91 Link Here
86	private IContributionItem[] fMenuContributions = null;	89	private IContributionItem[] fMenuContributions = null;
87	private IContributionItem[] fToolbarContributions = null;	90	private IContributionItem[] fToolbarContributions = null;
88	private final String OUTLINE_LINK_PREF = "outline-link-editor"; //$NON-NLS-1$	91	private final String OUTLINE_LINK_PREF = "outline-link-editor"; //$NON-NLS-1$
		92	private final String OUTLINE_FILTER_PREF = "org.eclipse.wst.sse.ui.OutlinePage"; //$NON-NLS-1$
		93	private String fOutlineFilterPref = OUTLINE_FILTER_PREF; //$NON-NLS-1$
89	ImageDescriptor SYNCED_D = EditorPluginImageHelper.getInstance().getImageDescriptor(EditorPluginImages.IMG_DLCL_SYNCED);	94	ImageDescriptor SYNCED_D = EditorPluginImageHelper.getInstance().getImageDescriptor(EditorPluginImages.IMG_DLCL_SYNCED);
90	ImageDescriptor SYNCED_E = EditorPluginImageHelper.getInstance().getImageDescriptor(EditorPluginImages.IMG_ELCL_SYNCED);	95	ImageDescriptor SYNCED_E = EditorPluginImageHelper.getInstance().getImageDescriptor(EditorPluginImages.IMG_ELCL_SYNCED);
91		96
Lines 313-316 Link Here
313	fMenuContributions = null;	318	fMenuContributions = null;
314	}	319	}
315	}	320	}
		321
		322	protected String getOutlineFilterTarget(){
		323	return fOutlineFilterPref ;
		324	}
		325
		326	public void setViewer(TreeViewer viewer){
		327	fTreeViewer = viewer;
		328	}
		329
		330	public void handleCustomFilter(){
		331	CustomFilterProcessor filterProcessor = new CustomFilterProcessor(getPreferenceStore(), getOutlineFilterTarget(), fTreeViewer);
		332	filterProcessor.openDialog();
		333	}
316	}	334	}

Lines 154-156 Link Here

(-)plugin.properties (+8 lines)
154		154
155	# XML Documentation view	155	# XML Documentation view
156	xmlannotations=Documentation	156	xmlannotations=Documentation
		157
		158	# outline filter
		159	HideComments.label=Comments
		160	HideComments.description=Hides Comments
		161	HideProcessingInstruction.label=Processing Instructions
		162	HideProcessingInstruction.description=Hides Processing Instructions
		163	HideCDATASection.label=CDATA
		164	HideCDATASection.description=Hides CDATA Section Tags




			</state>
		</command>
	</extension>  
		 <extension
       point="org.eclipse.wst.sse.ui.outlineFilters">
       <filter
            targetId="org.eclipse.wst.xml.ui.OutlinePage"
            name="%HideComments.label"
            enabled="false"
            description="%HideComments.description"
            class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter"
            id="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter">
      </filter>
      <filter
            targetId="org.eclipse.wst.xml.ui.OutlinePage"
            name="%HideProcessingInstruction.label"
            enabled="false"
            description="%HideProcessingInstruction.description"
            class="org.eclipse.wst.xml.ui.views.contentoutline.XMLProcessingInstructionFilter"
            id="org.eclipse.wst.xml.ui.views.contentoutline.XMLProcessingInstructionFilter">
      </filter>
      <filter
            targetId="org.eclipse.wst.xml.ui.OutlinePage"
            name="%HideCDATASection.label"
            enabled="false"
            description="%HideCDATASection.description"
            class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCDATASectionFilter"
            id="org.eclipse.wst.xml.ui.views.contentoutline.XMLCDATASectionFilter">
      </filter>
</extension>
</plugin>




/*******************************************************************************
 * Copyright (c) 2010 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
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.ui.views.contentoutline;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.wst.xml.core.internal.document.CDATASectionImpl;

public class XMLCDATASectionFilter extends ViewerFilter {

	public boolean select(Viewer viewer, Object parent, Object element) {
		if (element instanceof CDATASectionImpl){
			return false;
		}
		return true;
	}

}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.xml.ui.views.contentoutline;


import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.wst.xml.core.internal.document.CommentImpl;


/**
 * Filters package declarations
 */
public class XMLCommentFilter extends ViewerFilter {

	/*
	 * @see ViewerFilter
	 */
	public boolean select(Viewer viewer, Object parent, Object element) {
		if (element instanceof CommentImpl){
			return false;
		}
		return true;
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/wst/xml/ui/views/contentoutline/XMLContentOutlineConfiguration.java (-2 / +7 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2001, 2008 IBM Corporation and others.	2	* Copyright (c) 2001, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 266-272 Link Here
266	* Preference key for Show Attributes	266	* Preference key for Show Attributes
267	*/	267	*/
268	private final String OUTLINE_SHOW_ATTRIBUTE_PREF = "outline-show-attribute"; //$NON-NLS-1$	268	private final String OUTLINE_SHOW_ATTRIBUTE_PREF = "outline-show-attribute"; //$NON-NLS-1$
269		269	private final String OUTLINE_FILTER_PREF = "org.eclipse.wst.xml.ui.OutlinePage"; //$NON-NLS-1$
		270
270	/**	271	/**
271	* Create new instance of XMLContentOutlineConfiguration	272	* Create new instance of XMLContentOutlineConfiguration
272	*/	273	*/
Lines 408-411 Link Here
408	}	409	}
409	return filteredSelection;	410	return filteredSelection;
410	}	411	}
		412
		413	protected String getOutlineFilterTarget(){
		414	return OUTLINE_FILTER_PREF ;
		415	}
411	}	416	}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.xml.ui.views.contentoutline;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.wst.xml.core.internal.document.ProcessingInstructionImpl;

public class XMLProcessingInstructionFilter extends ViewerFilter {

	public boolean select(Viewer viewer, Object parent, Object element) {
		if (element instanceof ProcessingInstructionImpl){
			return false;
		}
		return true;
	}

}

Return to bug 109045

Lines 1329-1332 Link Here

(-)plugin.xml (+19 lines)
1329	contentTypeID="org.eclipse.jst.jsp.core.jspsource">	1329	contentTypeID="org.eclipse.jst.jsp.core.jspsource">
1330	</categoriesConfiguration>	1330	</categoriesConfiguration>
1331	</extension>	1331	</extension>
		1332	<extension
		1333	point="org.eclipse.wst.sse.ui.outlineFilters">
		1334	<filter
		1335	targetId="org.eclipse.jst.jsp.ui.OutlinePage"
		1336	name="%HideImportDeclaration.label"
		1337	enabled="false"
		1338	description="%HideImportDeclaration.description"
		1339	class="org.eclipse.jst.jsp.ui.views.contentoutline.JSPImportDirectiveFilter"
		1340	id="org.eclipse.jst.jsp.ui.views.contentoutline.JSPImportDirectiveFilter">
		1341	</filter>
		1342	<filter
		1343	targetId="org.eclipse.jst.jsp.ui.OutlinePage"
		1344	name="%HideComments.label"
		1345	enabled="false"
		1346	description="%HideComments.description"
		1347	class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter"
		1348	id="org.eclipse.jst.jsp.ui.views.contentoutline.XMLCommentFilter">
		1349	</filter>
		1350	</extension>
1332	</plugin>	1351	</plugin>

Lines 1782-1785 Link Here

(-)plugin.xml (+27 lines)
1782	</state>	1782	</state>
1783	</command>	1783	</command>
1784	</extension>	1784	</extension>
		1785	<extension
		1786	point="org.eclipse.wst.sse.ui.outlineFilters">
		1787	<filter
		1788	targetId="org.eclipse.wst.xml.ui.OutlinePage"
		1789	name="%HideComments.label"
		1790	enabled="false"
		1791	description="%HideComments.description"
		1792	class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter"
		1793	id="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter">
		1794	</filter>
		1795	<filter
		1796	targetId="org.eclipse.wst.xml.ui.OutlinePage"
		1797	name="%HideProcessingInstruction.label"
		1798	enabled="false"
		1799	description="%HideProcessingInstruction.description"
		1800	class="org.eclipse.wst.xml.ui.views.contentoutline.XMLProcessingInstructionFilter"
		1801	id="org.eclipse.wst.xml.ui.views.contentoutline.XMLProcessingInstructionFilter">
		1802	</filter>
		1803	<filter
		1804	targetId="org.eclipse.wst.xml.ui.OutlinePage"
		1805	name="%HideCDATASection.label"
		1806	enabled="false"
		1807	description="%HideCDATASection.description"
		1808	class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCDATASectionFilter"
		1809	id="org.eclipse.wst.xml.ui.views.contentoutline.XMLCDATASectionFilter">
		1810	</filter>
		1811	</extension>
1785	</plugin>	1812	</plugin>

Lines 35-41 Link Here

(-)src/org/eclipse/jst/jsp/ui/views/contentoutline/JSPContentOutlineConfiguration.java (-2 / +6 lines)
35	// be used	35	// be used
36	// private StructuredContentOutlineConfiguration fEmbeddedConfiguration =	36	// private StructuredContentOutlineConfiguration fEmbeddedConfiguration =
37	// null;	37	// null;
38		38	private final String OUTLINE_FILTER_PREF = "org.eclipse.jst.jsp.ui.OutlinePage"; //$NON-NLS-1$
39	/**	39	/**
40	* Create new instance of JSPContentOutlineConfiguration	40	* Create new instance of JSPContentOutlineConfiguration
41	*/	41	*/
Lines 49-59 Link Here
49	*	49	*
50	* @see org.eclipse.wst.sse.ui.views.contentoutline.ContentOutlineConfiguration#getPreferenceStore()	50	* @see org.eclipse.wst.sse.ui.views.contentoutline.ContentOutlineConfiguration#getPreferenceStore()
51	*/	51	*/
52	protected IPreferenceStore getPreferenceStore() {	52	public IPreferenceStore getPreferenceStore() {
53	return JSPUIPlugin.getDefault().getPreferenceStore();	53	return JSPUIPlugin.getDefault().getPreferenceStore();
54	}	54	}
55		55
56	protected XMLNodeActionManager createNodeActionManager(TreeViewer treeViewer) {	56	protected XMLNodeActionManager createNodeActionManager(TreeViewer treeViewer) {
57	return new JSPNodeActionManager((IStructuredModel) treeViewer.getInput(), treeViewer);	57	return new JSPNodeActionManager((IStructuredModel) treeViewer.getInput(), treeViewer);
58	}	58	}
		59
		60	public String getOutlineFilterTarget(){
		61	return OUTLINE_FILTER_PREF ;
		62	}
59	}	63	}

Added Link Here

(-)src/org/eclipse/jst/jsp/ui/views/contentoutline/JSPImportDirectiveFilter.java (+44 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jst.jsp.ui.views.contentoutline;
12
13	import org.eclipse.jdt.internal.ui.filters.ImportDeclarationFilter;
14	import org.eclipse.jface.viewers.Viewer;
15	import org.eclipse.jst.jsp.core.internal.contentmodel.tld.provisional.JSP20TLDNames;
16	import org.eclipse.jst.jsp.core.internal.provisional.JSP11Namespace;
17	import org.w3c.dom.NamedNodeMap;
18	import org.w3c.dom.Node;
19
20	public class JSPImportDirectiveFilter extends ImportDeclarationFilter {
21
22
23	/*
24	* @see ViewerFilter
25	*/
26	public boolean select(Viewer viewer, Object parent, Object element) {
27	if (super.select(viewer, parent, element)){
28	if (element instanceof Node){
29	Node node = (Node)element;
30	if (node.getNodeName().equalsIgnoreCase(JSP11Namespace.ElementName.DIRECTIVE_PAGE)){
31	NamedNodeMap nodeMap = node.getAttributes();
32	for (int i=0;i <nodeMap.getLength();i++){
33	Node attr = nodeMap.item(i);
34	if (attr.toString().equalsIgnoreCase(JSP20TLDNames.IMPORT))
35	return false;
36	}
37	}
38	}
39	return true;
40	}
41	else
42	return false;
43	}
44	}

Lines 700-704 Link Here

(-)plugin.xml (+12 lines)
700	contentTypeID="org.eclipse.wst.html.core.htmlsource">	700	contentTypeID="org.eclipse.wst.html.core.htmlsource">
701	</categoriesConfiguration>	701	</categoriesConfiguration>
702	</extension>	702	</extension>
		703
		704	<extension
		705	point="org.eclipse.wst.sse.ui.outlineFilters">
		706	<filter
		707	targetId="org.eclipse.wst.html.ui.OutlinePage"
		708	name="%HideComments.label"
		709	enabled="false"
		710	description="%HideComments.description"
		711	class="org.eclipse.wst.xml.ui.views.contentoutline.XMLCommentFilter"
		712	id="org.eclipse.wst.html.ui.views.contentoutline.XMLCommentFilter">
		713	</filter>
		714	</extension>
703		715
704	</plugin>	716	</plugin>

Added Link Here

(-)schema/outlineFilters.exsd (+136 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.wst.sse.ui" xmlns="http://www.w3.org/2001/XMLSchema">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.wst.sse.ui" id="outlineFilters" name="%outlineFiltersName"/>
7	</appInfo>
8	<documentation>
9	[Enter description of this extension point.]
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<annotation>
15	<appInfo>
16	<meta.element />
17	</appInfo>
18	</annotation>
19	<complexType>
20	<sequence>
21	<element ref="filter" minOccurs="1" maxOccurs="unbounded"/>
22	</sequence>
23	<attribute name="point" type="string" use="required">
24	<annotation>
25	<documentation>
26	a fully qualified identifier of the target extension point
27	</documentation>
28	</annotation>
29	</attribute>
30	<attribute name="id" type="string">
31	<annotation>
32	<documentation>
33	an optional identifier of the extension instance
34	</documentation>
35	</annotation>
36	</attribute>
37	<attribute name="name" type="string">
38	<annotation>
39	<documentation>
40	an optional name of the extension instance
41	</documentation>
42	<appInfo>
43	<meta.attribute translatable="true"/>
44	</appInfo>
45	</annotation>
46	</attribute>
47	</complexType>
48	</element>
49
50	<element name="filter">
51	<annotation>
52	<appInfo>
53	<meta.element labelAttribute="name"/>
54	</appInfo>
55	</annotation>
56	<complexType>
57	<attribute name="id" type="string">
58	<annotation>
59	<documentation>
60	a unique id that will be used to identify this filter
61	</documentation>
62	</annotation>
63	</attribute>
64	<attribute name="name" type="string">
65	<annotation>
66	<documentation>
67	a unique name that allows to identify this filter in the UI. This attribute should be a translated string. Though this attribute is not required for pattern filters (i.e. those using the <samp>pattern</samp> attribute) we suggest to provide a name anyway, otherwise the pattern string itself would be used to represent the filter in the UI.
68	</documentation>
69	<appInfo>
70	<meta.attribute translatable="true"/>
71	</appInfo>
72	</annotation>
73	</attribute>
74	<attribute name="description" type="string">
75	<annotation>
76	<documentation>
77	a short description for this filter
78	</documentation>
79	<appInfo>
80	<meta.attribute translatable="true"/>
81	</appInfo>
82	</annotation>
83	</attribute>
84	<attribute name="targetId" type="string">
85	<annotation>
86	<documentation>
87	the id of the target where this filter is contributed. If this attribute is missing, then the filter will
88	be contributed to all views which use the <code>org.eclipse.wst.sse.ui.actions.CustomFiltersAction</code>.
89	</documentation>
90	</annotation>
91	</attribute>
92	<attribute name="enabled" type="boolean">
93	<annotation>
94	<documentation>
95	the filter will be enabled if this attribute is "true" or if this attribute is not present. Most likely the user will be able to override this setting in the UI.
96	</documentation>
97	</annotation>
98	</attribute>
99	<attribute name="class" type="string">
100	<annotation>
101	<documentation>
102	the name of the class used to filter the view. The class must extend <code>org.eclipse.jface.viewers.ViewerFilter</code>. If this attribute is here
103	then the pattern attribute must not provided.
104	</documentation>
105	<appInfo>
106	<meta.attribute kind="java" basedOn="org.eclipse.jface.viewers.ViewerFilter"/>
107	</appInfo>
108	</annotation>
109	</attribute>
110	</complexType>
111	</element>
112
113
114	<annotation>
115	<appInfo>
116	<meta.section type="examples"/>
117	</appInfo>
118	<documentation>
119	Works similar to javaElementFilter definition with targetId as "org.wst.sse.ui.OutlinePage".
120	Target id can be changed for different content types to provide their own filters
121	</documentation>
122	</annotation>
123
124
125
126	<annotation>
127	<appInfo>
128	<meta.section type="copyright"/>
129	</appInfo>
130	<documentation>
131	Copyright (c) 2010 IBM Corporation and others.<br>
132	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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
133	</documentation>
134	</annotation>
135
136	</schema>

Added Link Here

(-)src/org/eclipse/wst/sse/ui/internal/filter/CustomFilterProcessor.java (+325 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.sse.ui.internal.filter;
12	import java.util.ArrayList;
13	import java.util.HashMap;
14	import java.util.HashSet;
15	import java.util.Iterator;
16	import java.util.Map;
17
18	import org.eclipse.core.runtime.Assert;
19	import org.eclipse.jface.preference.IPreferenceStore;
20	import org.eclipse.jface.viewers.StructuredViewer;
21	import org.eclipse.jface.viewers.ViewerFilter;
22	import org.eclipse.jface.window.Window;
23
24	/**
25	* Action group to add the filter action to a view part's tool bar
26	* menu.
27	* <p>
28	* This class may be instantiated; it is not intended to be subclassed.
29	* </p>
30	*
31	* @noextend This class is not intended to be subclassed by clients.
32	*/
33	public class CustomFilterProcessor {
34
35
36	private static final String SEPARATOR= ","; //$NON-NLS-1$
37	private final String TAG_USER_DEFINED_PATTERNS_ENABLED= "userDefinedPatternsEnabled"; //$NON-NLS-1$
38	private final String TAG_USER_DEFINED_PATTERNS= "userDefinedPatterns"; //$NON-NLS-1$
39
40
41	private static class FilterItem {
42	boolean enabled;
43	boolean previouslyEnabled;
44	OutlineFilterDescriptor descriptor;
45	String id;
46
47	private ViewerFilter filterInstance= null;
48
49	public FilterItem(OutlineFilterDescriptor descriptor) {
50	this.descriptor= descriptor;
51	this.id= descriptor.getId();
52	this.previouslyEnabled= false;
53	this.enabled= descriptor.isEnabled();
54	}
55
56	public ViewerFilter getFilterInstance() {
57	if (filterInstance == null) {
58	filterInstance= descriptor.createViewerFilter();
59	}
60	return filterInstance;
61
62	}
63	}
64
65
66	private final StructuredViewer fViewer;
67	private final OutlineNamePatternFilter fPatternFilter;
68
69	private boolean fUserDefinedPatternsEnabled;
70	private String[] fUserDefinedPatterns;
71
72	private String[] fPreviousPatterns;
73
74	private final Map fFilterItems;
75
76
77
78	private final String fTargetId;
79	private IPreferenceStore fStore;
80
81
82	/**
83	* Creates a new <code>CustomFilterAction</code>.
84	*
85	* @param store the preference Store
86	* @param ownerId the id of this action group's owner
87	* @param viewer the viewer to be filtered
88	*/
89	public CustomFilterProcessor(IPreferenceStore store,String ownerId, StructuredViewer viewer) {
90	Assert.isNotNull(ownerId);
91	Assert.isNotNull(viewer);
92	fStore = store;
93	fTargetId= ownerId;
94	fViewer= viewer;
95	fPatternFilter= new OutlineNamePatternFilter();
96
97	fUserDefinedPatterns= new String[0];
98	fUserDefinedPatternsEnabled= false;
99	fPreviousPatterns= new String[0];
100
101	fFilterItems= new HashMap();
102	OutlineFilterDescriptor[] filterDescriptors= OutlineFilterDescriptor.getFilterDescriptors(fTargetId);
103	for (int i= 0; i < filterDescriptors.length; i++) {
104	FilterItem item= new FilterItem(filterDescriptors[i]);
105	fFilterItems.put(item.id, item);
106
107	}
108
109	initializeWithViewDefaults();
110
111	updateViewerFilters();
112
113	}
114
115
116
117
118	/*
119	* @see org.eclipse.jface.action.IContributionItem#isDynamic()
120	*/
121	public boolean isDynamic() {
122	return true;
123	}
124	/**
125	* Returns a list of currently enabled filters. The filter
126	* is identified by its id.
127	* <p>
128	* This method is for internal use only and should not
129	* be called by clients outside of JDT/UI.
130	* </p>
131	*
132	* @return a list of currently enabled filters
133	*
134	* @noreference This method is not intended to be referenced by clients.
135	*/
136	public String[] internalGetEnabledFilterIds() {
137	ArrayList enabledFilterIds= new ArrayList();
138	for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
139	FilterItem item= (FilterItem) iterator.next();
140	if (item.enabled) {
141	enabledFilterIds.add(item.id);
142	}
143	}
144	return (String[])enabledFilterIds.toArray(new String[enabledFilterIds.size()]);
145	}
146
147	private void setEnabledFilterIds(String[] enabledIds) {
148	// set all to false
149	fUserDefinedPatternsEnabled= false;
150	for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
151	FilterItem item= (FilterItem) iterator.next();
152	item.enabled= false;
153	}
154	// set enabled to true
155	for (int i= 0; i < enabledIds.length; i++) {
156	FilterItem item= (FilterItem) fFilterItems.get(enabledIds[i]);
157	if (item != null) {
158	item.enabled= true;
159	}
160	if (fPatternFilter.getClass().getName().equals(enabledIds[i]))
161	fUserDefinedPatternsEnabled= true;
162	}
163	}
164
165	private void setUserDefinedPatterns(String[] patterns) {
166	fUserDefinedPatterns= patterns;
167	}
168
169
170	private boolean areUserDefinedPatternsEnabled() {
171	return fUserDefinedPatternsEnabled;
172	}
173
174	private void setUserDefinedPatternsEnabled(boolean state) {
175	fUserDefinedPatternsEnabled= state;
176	}
177
178
179	// ---------- viewer filter handling ----------
180
181	private boolean updateViewerFilters() {
182	ViewerFilter[] installedFilters= fViewer.getFilters();
183	ArrayList viewerFilters= new ArrayList(installedFilters.length);
184
185	HashSet patterns= new HashSet();
186
187	boolean hasChange= false;
188	boolean patternChange= false;
189
190	for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
191	FilterItem item= (FilterItem) iterator.next();
192	if (item.descriptor.isCustomFilter()) {
193	if (item.enabled != item.previouslyEnabled) {
194	hasChange = true;
195	}
196	if (item.enabled){
197	ViewerFilter filter= item.getFilterInstance(); // only create when changed
198	if (filter != null) {
199	viewerFilters.add(filter);
200	}
201	}
202	} else if (item.descriptor.isPatternFilter()) {
203	if (item.enabled) {
204	patterns.add(item.descriptor.getPattern());
205	}
206	patternChange \|= (item.enabled != item.previouslyEnabled);
207	}
208	item.previouslyEnabled= item.enabled;
209	}
210
211	if (areUserDefinedPatternsEnabled()) {
212	for (int i= 0; i < fUserDefinedPatterns.length; i++) {
213	patterns.add(fUserDefinedPatterns[i]);
214	}
215	}
216	if (!patternChange) { // no pattern change so far, test if the user patterns made a difference
217	patternChange= hasChanges(patterns, fPreviousPatterns);
218	}
219
220	fPreviousPatterns= (String[]) patterns.toArray(new String[patterns.size()]);
221	if (patternChange) {
222	fPatternFilter.setPatterns(fPreviousPatterns);
223	if (patterns.isEmpty()) {
224	viewerFilters.remove(fPatternFilter);
225	} else if (!viewerFilters.contains(fPatternFilter)) {
226	boolean contains = false;
227	for (int i=0; i< viewerFilters.size();i++){
228	if (viewerFilters.get(i) instanceof OutlineNamePatternFilter){
229	OutlineNamePatternFilter filter = (OutlineNamePatternFilter)viewerFilters.get(i);
230	String[] a1 =filter.getPatterns();
231	String[] a2 =fPatternFilter.getPatterns();
232	if (a1[0].equals(a2[0]))
233	contains= true;
234	else {
235	viewerFilters.remove(i);
236	}
237	break;
238	}
239	}
240	if (!contains)
241	viewerFilters.add(fPatternFilter);
242	}
243	hasChange= true;
244	}
245	if (hasChange) {
246	fViewer.setFilters((ViewerFilter[]) viewerFilters.toArray(new ViewerFilter[viewerFilters.size()])); // will refresh
247	}
248	return hasChange;
249	}
250
251	private boolean hasChanges(HashSet patterns, String[] oldPatterns) {
252	HashSet copy= (HashSet) patterns.clone();
253	for (int i= 0; i < oldPatterns.length; i++) {
254	boolean found= copy.remove(oldPatterns[i]);
255	if (!found)
256	return true;
257	}
258	return !copy.isEmpty();
259	}
260
261	// ---------- view kind/defaults persistency ----------
262
263	private void initializeWithViewDefaults() {
264	// get default values for view
265
266
267	fUserDefinedPatternsEnabled= fStore.getBoolean(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED));
268	setUserDefinedPatterns(OutlineCustomFiltersDialog.convertFromString(fStore.getString(getPreferenceKey(TAG_USER_DEFINED_PATTERNS)), SEPARATOR));
269
270	for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
271	FilterItem item= (FilterItem) iterator.next();
272	String id= item.id;
273	// set default to value from plugin contributions (fixes https://bugs.eclipse.org/bugs/show_bug.cgi?id=73991 ):
274	fStore.setDefault(id, item.descriptor.isEnabled());
275	item.enabled= fStore.getBoolean(id);
276	}
277
278	}
279
280	private void storeViewDefaults() {
281	// get default values for view
282
283	fStore.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED), fUserDefinedPatternsEnabled);
284	fStore.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS), OutlineCustomFiltersDialog.convertToString(fUserDefinedPatterns ,SEPARATOR));
285
286	boolean fFilterSelected = false;
287	for (Iterator iterator= fFilterItems.values().iterator(); iterator.hasNext();) {
288	FilterItem item= (FilterItem) iterator.next();
289	fStore.setValue(item.id, item.enabled);
290	if (item.enabled)
291	fFilterSelected = true;
292	}
293
294	fStore.setValue(fTargetId, fUserDefinedPatternsEnabled \|\| fFilterSelected);
295
296	}
297
298	private String getPreferenceKey(String tag) {
299	return "CustomFiltersActionGroup." + fTargetId + '.' + tag; //$NON-NLS-1$
300	}
301
302
303	public void openDialog() {
304	OutlineCustomFiltersDialog dialog= new OutlineCustomFiltersDialog(
305	fViewer.getControl().getShell(),
306	fTargetId,
307	areUserDefinedPatternsEnabled(),
308	fUserDefinedPatterns,
309	internalGetEnabledFilterIds());
310
311	if (dialog.open() == Window.OK) {
312
313	setEnabledFilterIds(dialog.getEnabledFilterIds());
314	setUserDefinedPatternsEnabled(dialog.areUserDefinedPatternsEnabled());
315	setUserDefinedPatterns(dialog.getUserDefinedPatterns());
316	storeViewDefaults();
317
318	updateViewerFilters();
319	}
320	else {
321	storeViewDefaults();
322	}
323	}
324	}
325

Added Link Here

(-)src/org/eclipse/wst/sse/ui/internal/filter/OutlineFilterMessages.properties (+24 lines)
1	###############################################################################
2	# Copyright (c) 2010 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at
6	# http://www.eclipse.org/legal/epl-v10.html
7	#
8	# Contributors:
9	# IBM Corporation - initial API and implementation
10	###############################################################################
11
12	CustomFiltersDialog_title= Java Element Filters
13	CustomFiltersDialog_patternInfo= The patterns are separated by comma, where\n* = any string, ? = any character, ,, = ,
14	CustomFiltersDialog_enableUserDefinedPattern= &Name filter patterns (matching names will be hidden):
15	CustomFiltersDialog_filterList_label= S&elect the elements to exclude from the view:
16	CustomFiltersDialog_description_label= Filter description:
17	CustomFiltersDialog_SelectAllButton_label= &Select All
18	CustomFiltersDialog_DeselectAllButton_label= &Deselect All
19	CustomFiltersDialog_name_filter_pattern_description=Name filter patterns. The patterns are separated by comma, where star is any string
20
21	OpenCustomFiltersDialogAction_text= &Filters...
22
23	FilterDescriptor_filterDescriptionCreationError_message= One of the extensions for extension-point org.eclipse.wst.sse.ui.outlineFilters is incorrect.
24	FilterDescriptor_filterCreationError_message= The org.eclipse.wst.sse.ui.outlineFilters plug-in extension "{0}" specifies a viewer filter class which does not exist.

Added Link Here

(-)src/org/eclipse/wst/sse/ui/internal/handlers/CustomFilterHandler.java (+32 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.sse.ui.internal.handlers;
12
13	import org.eclipse.core.commands.AbstractHandler;
14	import org.eclipse.core.commands.ExecutionEvent;
15	import org.eclipse.core.commands.ExecutionException;
16	import org.eclipse.ui.IEditorPart;
17	import org.eclipse.ui.handlers.HandlerUtil;
18	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
19	import org.eclipse.wst.sse.ui.internal.contentoutline.ConfigurableContentOutlinePage;
20
21	public class CustomFilterHandler extends AbstractHandler {
22	public Object execute(ExecutionEvent event) throws ExecutionException {
23
24	IEditorPart editor = HandlerUtil.getActiveEditor(event);
25	ConfigurableContentOutlinePage page = (ConfigurableContentOutlinePage) editor.getAdapter(IContentOutlinePage.class);
26	if (page != null) {
27	page.getConfiguration().handleCustomFilter();
28	}
29	return null;
30	}
31
32	}