HideImportDeclaration.label=Import Directive

HideImportDeclaration.description=Hides Import Directives

HideFontStyle.label=Font Style

HideFontStyle.description=Hides Font Style Tags

 <extension

       point="org.eclipse.wst.sse.ui.sseElementFilter">

       <filter

            targetId="org.eclipse.jst.jsp.ui.OutlinePage"

            name="%HideImportDeclaration.label"

            enabled="false"

            description="%HideImportDeclaration.description"

            class="org.eclipse.jdt.internal.ui.filters.ImportDeclarationFilter"

            id="org.eclipse.jst.jsp.ui.filters.ImportDeclarationFilter">

       </filter>

       <filter

            targetId="org.eclipse.jst.jsp.ui.OutlinePage"

           name="%HideFontStyle.label"

            enabled="false"

            description="%HideFontStyle.description"

            class="org.eclipse.wst.html.ui.views.contentoutline.HTMLFontStyleFilter"

            id="org.eclipse.jst.jsp.ui.views.contentoutline.HTMLFontStyleFilter">

       </filter>

 </extension>

		super.setOutlineFilterTarget(OUTLINE_FILTER_PREF);

HideFontStyle.label=Font Style

HideFontStyle.description=Hides Font Style Tags

 <extension

       point="org.eclipse.wst.sse.ui.sseElementFilter">

       <filter

            targetId="org.eclipse.wst.html.ui.OutlinePage"

            name="%HideFontStyle.label"

            enabled="false"

            description="%HideFontStyle.description"

            class="org.eclipse.wst.html.ui.views.contentoutline.HTMLFontStyleFilter"

            id="org.eclipse.wst.html.ui.views.contentoutline.HTMLFontStyleFilter">

      </filter>

 </extension>

		super.setOutlineFilterTarget(OUTLINE_FILTER_PREF);

package org.eclipse.wst.html.ui.views.contentoutline;

import java.util.ArrayList;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.wst.html.core.internal.document.ElementStyleImpl;

import org.eclipse.wst.html.core.internal.provisional.HTML40Namespace;

public class HTMLFontStyleFilter extends ViewerFilter {

	final static ArrayList fontStyles = new ArrayList(9);

	static {

		fontStyles.add(HTML40Namespace.ElementName.TT.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.I.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.B.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.P.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.S.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.STRIKE.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.BIG.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.SMALL.toLowerCase());

		fontStyles.add(HTML40Namespace.ElementName.U.toLowerCase());

	}

	public boolean select(Viewer viewer, Object parentElement, Object element) {

		if (element instanceof ElementStyleImpl){

			ElementStyleImpl elemImpl = (ElementStyleImpl)element;

			String nodeName = elemImpl.getNodeName().toLowerCase();

			if (fontStyles.contains(nodeName)){

				return false;

			}

		}

		return true;

	}

}

#Filter Support

HideImportDeclaration.label= Import declarations

HideImportDeclaration.description= Hides all import declarations

elementFiltersName=SSE Element Filters

 <extension-point id="sseElementFilter" name="%elementFiltersName" schema="schema/sseElementFilter.exsd"/>

<?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="sseElementFilter" name="%elementFiltersName"/>

      </appInfo>

      <documentation>

         [Enter description of this extension point.]

      </documentation>

   </annotation>

   <element name="extension">

   	  <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 <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.

               </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 <code>org.eclipse.wst.sse.ui.actions.CustomFiltersAction</code>. This

replaces the deprecated attribute "viewId".

               </documentation>

            </annotation>

         </attribute>

         <attribute name="enabled" type="boolean">

            <annotation>

               <documentation>

                  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.

               </documentation>

            </annotation>

         </attribute>

         <attribute name="pattern" type="string">

            <annotation>

               <documentation>

                  elements whose name matches this pattern will be hidden. This attribute is here for backward compatibility and should no longer be used. All views that allow to plug-in a filter also allow to add pattern filters directly via 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 <code>org.eclipse.jface.viewers.ViewerFilter</code>. 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 "org.wst.sse.ui.OutlinePage".

         Target id can be changed for different content types to provide their own filters

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="apiInfo"/>

      </appInfo>

      <documentation>

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="implementation"/>

      </appInfo>

      <documentation>

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="copyright"/>

      </appInfo>

      <documentation>

         Copyright (c) 2001, 2010 IBM Corporation and others.<br>

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>

      </documentation>

   </annotation>

</schema>

/*******************************************************************************

 * Copyright (c) 2000, 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.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 SSECustomFiltersDialog extends SelectionDialog {

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

	private String fViewId;

	private boolean fEnablePatterns;

	private String[] fPatterns;

	private String[] fEnabledFilterIds;

	private SSEFilterDescriptor[] 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 SSECustomFiltersDialog(

			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= SSEFilterDescriptor.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(SSEFilterMessages.CustomFiltersDialog_title);

		setMessage(SSEFilterMessages.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(SSEFilterMessages.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, SSEFilterMessages.CustomFiltersDialog_name_filter_pattern_description);

		// Info text

		final Label info= new Label(group, SWT.LEFT);

		info.setText(SSEFilterMessages.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(SSEFilterMessages.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(SSEFilterMessages.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 SSEFilterDescriptor)

						description.setText(((SSEFilterDescriptor)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 SSEFilterDescriptor) {

					// 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= SSEFilterMessages.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= SSEFilterMessages.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 SSEFilterDescriptor)

						return ((SSEFilterDescriptor)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(((SSEFilterDescriptor)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

	 * @since 3.0

	 */

	public Stack getFilterDescriptorChangeHistory() {

		return fFilterDescriptorChangeHistory;

	}

	private SSEFilterDescriptor[] getEnabledFilterDescriptors() {

		SSEFilterDescriptor[] 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 (SSEFilterDescriptor[])result.toArray(new SSEFilterDescriptor[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) 2000, 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.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.jdt.ui.javaElementFilters" extension point.

 *

 * since 2.0

 */

public class SSEFilterDescriptor implements Comparable, IPluginContribution {

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

	private static final String EXTENSION_POINT_NAME= "sseElementFilter"; //$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$

	/**

	 * @deprecated as of 3.0 use {@link SSEFilterDescriptor#TARGET_ID_ATTRIBUTE}

	 */

	private static final String VIEW_ID_ATTRIBUTE= "viewId"; //$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$

	/**

	 * @deprecated	use "enabled" instead

	 */

	private static final String SELECTED_ATTRIBUTE= "selected"; //$NON-NLS-1$

	private static SSEFilterDescriptor[] fgFilterDescriptors;

	private IConfigurationElement fElement;

	/**

	 * Returns all contributed Java element filters.

	 * @return all contributed Java element filters

	 */

	public static SSEFilterDescriptor[] 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 SSEFilterDescriptor[] getFilterDescriptors(String targetId) {

		SSEFilterDescriptor[] filterDescs= SSEFilterDescriptor.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 (SSEFilterDescriptor[])result.toArray(new SSEFilterDescriptor[result.size()]);

	}

	/**

	 * Creates a new filter descriptor for the given configuration element.

	 * @param element configuration element

	 */

	private SSEFilterDescriptor(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.jdt.ui.javaElementFilters does not specify a correct filter"); //$NON-NLS-1$

		Assert.isNotNull(getId(), "An extension for extension-point org.eclipse.jdt.ui.javaElementFilters does not provide a valid ID"); //$NON-NLS-1$

		Assert.isNotNull(getName(), "An extension for extension-point org.eclipse.jdt.ui.javaElementFilters 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 = SSEFilterMessages.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

	 * @since 3.0

	 */

	public String getTargetId() {

		String tid= fElement.getAttribute(TARGET_ID_ATTRIBUTE);

		if (tid != null)

			return tid;

		// Backwards compatibility code

		return fElement.getAttribute(VIEW_ID_ATTRIBUTE);

	}

	/**

	 * 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);

		if (strVal == null)

			// backward compatibility

			strVal= fElement.getAttribute(SELECTED_ATTRIBUTE);

		return strVal == null || Boolean.valueOf(strVal).booleanValue();

	}

	/*

	 * Implements a method from IComparable

	 */

	public int compareTo(Object o) {

		if (o instanceof SSEFilterDescriptor)

			return Collator.getInstance().compare(getName(), ((SSEFilterDescriptor)o).getName());

		else

			return Integer.MIN_VALUE;

	}

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

	/**

	 * Creates the filter descriptors.

	 * @param elements the configuration elements

	 * @return new filter descriptors

	 */

	private static SSEFilterDescriptor[] 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 SSEFilterDescriptor[] desc= new SSEFilterDescriptor[1];

				SafeRunner.run(new SafeRunnable(SSEFilterMessages.FilterDescriptor_filterDescriptionCreationError_message) {

					public void run() throws Exception {

						desc[0]= new SSEFilterDescriptor(element);

					}

				});

				if (desc[0] != null && !descIds.contains(desc[0].getId())) {

					result.add(desc[0]);

					descIds.add(desc[0].getId());

				}

			}

		}

		return (SSEFilterDescriptor[])result.toArray(new SSEFilterDescriptor[result.size()]);

	}

	public String getLocalId() {

		return fElement.getAttribute(ID_ATTRIBUTE);

	}

    public String getPluginId() {

        return fElement.getContributor().getName();

    }

}

/*******************************************************************************

 * Copyright (c) 2000, 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.filter;

import org.eclipse.osgi.util.NLS;

public final class SSEFilterMessages extends NLS {

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

	private SSEFilterMessages() {

		// 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, SSEFilterMessages.class);

	}

}

###############################################################################

# Copyright (c) 2000, 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.sseElementFilters is incorrect.

FilterDescriptor_filterCreationError_message= The org.eclipse.wst.sse.ui.sssElementFilters plug-in extension "{0}" specifies a viewer filter class which does not exist.

/*******************************************************************************

 * Copyright (c) 2000, 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.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>

 *

 * @since 2.0

 */

public class SSENamePatternFilter extends ViewerFilter {

	private String[] fPatterns;

	private SSEStringMatcher[] 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 SSEStringMatcher(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 SSEStringMatcher[newPatterns.length];

		for (int i = 0; i < newPatterns.length; i++) {

			//Reset the matchers to prevent constructor overhead

			fMatchers[i]= new SSEStringMatcher(newPatterns[i], true, false);

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2000, 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.filter;

import java.util.Vector;

/**

 * A string pattern matcher. Supports '*' and '?' wildcards.

 */

public class SSEStringMatcher {

	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 SSEStringMatcher(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 SSEStringMatcher.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) 2000, 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.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 {

	/**

	 * The default visible item count for {@link Combo}s.

	 * Workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=245569 .

	 *

	 * @see Combo#setVisibleItemCount(int)

	 *

	 * @since 3.5

	 */

	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;

			}

		});

	}

	/**

	 * Sets the default visible item count for {@link Combo}s.

	 * Workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=7845 .

	 *

	 * @param combo the combo

	 *

	 * @see Combo#setVisibleItemCount(int)

	 * @see #COMBO_VISIBLE_ITEM_COUNT

	 *

	 * @since 3.5

	 */

	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;

	}

}

	public static String ContentOutlineConfiguration_2;

ContentOutlineConfiguration_2=Filters

	private final String OUTLINE_FILTER_PREF = "org.eclipse.wst.sse.ui.OutlinePage"; //$NON-NLS-1$

	private String fOutlineFilterPref = OUTLINE_FILTER_PREF; //$NON-NLS-1$

	// added

	public void setOutlineFilterTarget(String targetId){

		fOutlineFilterPref = targetId;

	}

package org.eclipse.wst.sse.ui.views.contentoutline;

	/*******************************************************************************

	 * Copyright (c) 2001, 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

	 *******************************************************************************/

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;

import org.eclipse.wst.sse.ui.filter.SSECustomFiltersDialog;

import org.eclipse.wst.sse.ui.filter.SSEFilterDescriptor;

import org.eclipse.wst.sse.ui.filter.SSENamePatternFilter;

import org.eclipse.wst.sse.ui.internal.SSEUIMessages;

import org.eclipse.wst.sse.ui.internal.contentoutline.PropertyChangeUpdateAction;

	/**

	 * 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>

	 *

	 * @since 2.0

	 *

	 * @noextend This class is not intended to be subclassed by clients.

	 */