import java.io.File;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Platform;

import org.eclipse.wst.common.snippets.internal.SnippetsPlugin;

import org.osgi.framework.Bundle;

	private List<String> deleted = new ArrayList<String>();

		for (String deletedId : deleted) {

			Bundle bundle = Platform.getBundle(SnippetsPlugin.BUNDLE_ID);

			IPath path = Platform.getStateLocation(bundle).append(deletedId);

			File folder = new File(path.toOSString());

			deleteFolders(folder);

		}

		deleted.clear();

	private void deleteFolders(File folder) {

		if (!folder.exists()){

			return;

		}

		File[] listFiles = folder.listFiles();

		for (File file : listFiles) {

			if (file.isDirectory()){

				deleteFolders(file);

			} else {

				file.delete();

			}

		}

		folder.delete();

	}

	@Override

	public void performDelete(PaletteEntry entry) {

		deleted.add(entry.getId());

		super.performDelete(entry);

	}

			} else {

				supportedTypes = new Transfer[]{TextTransfer.getInstance()};

import org.eclipse.wst.common.snippets.internal.util.SnippetProviderManager;

		item.setProvider(SnippetProviderManager.findProvider(element.getAttribute(SnippetsPlugin.NAMES.PROVIDER_ID)));

		if (item.getProvider() != null)

			element.setAttribute(SnippetsPlugin.NAMES.PROVIDER_ID, item.getProvider().getId());

	<classpathentry kind="src" path="src"/>

 <extension-point 

 	id="SnippetProvider" 

 	name="%extension-point.name.0" 

 	schema="schema/SnippetProvider.exsd"/>

 <extension

       point="org.eclipse.wst.common.snippets.SnippetProvider">

    <provider

          impl="org.eclipse.wst.common.snippets.ui.TextSnippetProvider"

          priority="100">

       <enablement>

          <instanceof

                value="org.eclipse.ui.texteditor.ITextEditor">

          </instanceof>

       </enablement>

    </provider>

 </extension>

extension-point.name.0 = SnippetProvider

		setProperty(item, SnippetsPlugin.NAMES.PROVIDER_ID, element.getAttribute(SnippetsPlugin.NAMES.PROVIDER_ID));

		if (((SnippetPaletteItem) item).getProvider() != null)

			element.setAttribute(SnippetsPlugin.NAMES.PROVIDER_ID, ((SnippetPaletteItem) item).getProvider().getId());

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

import java.util.Enumeration;

import java.util.zip.ZipEntry;

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

import org.eclipse.core.runtime.Platform;

import org.eclipse.wst.common.snippets.core.ISnippetItem;

import org.eclipse.wst.common.snippets.internal.SnippetsPlugin;

import org.osgi.framework.Bundle;

	private enum EXPORT_IMPORT_STRATEGY {

		ARCHIVE, XML;

	}

			EXPORT_IMPORT_STRATEGY strategy = exportStrategy(exportCategory);

					bis.close();

			}

		}

		}

		private SnippetDefinitions getCategory(PaletteDrawer exportCategory,

				String fileName) {

			SnippetDefinitions definitions = ModelFactoryForUser.getInstance().load(fileName);

			ISnippetCategory existingCategory = definitions.getCategory(exportCategory.getId());

			if (existingCategory == null)

				definitions.getCategories().add(exportCategory);

			else {

				String title = SnippetsMessages.SnippetCustomizerDialog_2; //$NON-NLS-1$

				String message = NLS.bind(SnippetsMessages.SnippetCustomizerDialog_4, new String[]{existingCategory.getLabel()});

				boolean answer = MessageDialog.openConfirm(getShell(), title, message);

				if (answer) {

					definitions.getCategories().remove(existingCategory);

					definitions.getCategories().add(exportCategory);

				}

			}

			return definitions;

		}

		private String openFileDialog(String extension) {

			final FileDialog fileDialog = new FileDialog(getShell(), SWT.SAVE);

			fileDialog.setText(SnippetsMessages.Export_Snippets);

			fileDialog.setFileName("snippets"+ extension.substring(1)); //$NON-NLS-1$

			String[] filterExtensions = new String[2];

			filterExtensions[0] = extension;

			filterExtensions[1] = "*.*"; //$NON-NLS-1$

			fileDialog.setFilterExtensions(filterExtensions);

			String filename = fileDialog.open();

			return filename;

	public static final void copyInputStream(InputStream in, OutputStream out)

	throws IOException

	{

		byte[] buffer = new byte[1024];

		int len;

		while((len = in.read(buffer)) >= 0)

			out.write(buffer, 0, len);

		in.close();

		out.close();

	}

	public void unzip(ZipFile zipFile, String path) throws FileNotFoundException, IOException {

		Enumeration entries;

		entries = zipFile.entries();

		while(entries.hasMoreElements()) {

			ZipEntry entry = (ZipEntry)entries.nextElement();

			File file = new File(path + File.separator+ entry.getName());

			if(entry.isDirectory()) {

				file.mkdir();

				continue;

			}

			if (!file.getParentFile().exists()){

				file.getParentFile().mkdirs();

			}

			if (entry.getName().toLowerCase().equals("snippets.xml")){

				continue;

			}

			copyInputStream(zipFile.getInputStream(entry), new BufferedOutputStream(new FileOutputStream(file)));

		}

		zipFile.close();

	}

	public SnippetDefinitions load(InputStream in) {

		SnippetDefinitions definitions = new SnippetDefinitions();

		Document document = null;

		try {

			DocumentBuilder builder = CommonXML.getDocumentBuilder();

			if (builder != null) {

				document = builder.parse(new InputSource(in));

			}

			else {

				Logger.log(Logger.ERROR, "Couldn't obtain a DocumentBuilder"); //$NON-NLS-1$

			}

		}

		catch (FileNotFoundException e) {

			// typical of new workspace, don't log it

			document = null;

		}

		catch (IOException e) {

			Logger.logException("Could not load user items", e); //$NON-NLS-1$

			return definitions;

		}

		catch (SAXException e) {

			Logger.logException("Could not load user items", e); //$NON-NLS-1$

			return definitions;

		}

		if (document == null)

			return definitions;

		Element library = document.getDocumentElement();

		if (library == null || !library.getNodeName().equals(SnippetsPlugin.NAMES.SNIPPETS))

			return definitions;

		loadDefinitions(definitions, library);

		connectItemsAndCategories(definitions);

		return definitions;

	}

		setProperty(item, SnippetsPlugin.NAMES.PROVIDER_ID, element.getAttribute(SnippetsPlugin.NAMES.PROVIDER_ID));

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Platform;

import org.eclipse.wst.common.snippets.core.ISnippetProvider;

import org.eclipse.wst.common.snippets.internal.SnippetsPlugin;

import org.osgi.framework.Bundle;

	private ISnippetProvider provider;

	public IPath getStorage() {

		Bundle bundle = Platform.getBundle(SnippetsPlugin.BUNDLE_ID);

		return Platform.getStateLocation(bundle).append(getId());

	}

	public ISnippetProvider getProvider() {

		return provider;

	}

	public void setProvider(ISnippetProvider provider) {

		this.provider = provider;

	}

import org.eclipse.wst.common.snippets.internal.util.SnippetProviderManager;

		else if (property.equals(SnippetsPlugin.NAMES.PROVIDER_ID))

			item.setProvider(SnippetProviderManager.findProvider(propertyValue.toString()));

import org.eclipse.core.runtime.CoreException;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.OutputStream;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.osgi.framework.Bundle;

	public IPath getStorage(String id) {

		Bundle bundle = Platform.getBundle(SnippetsPlugin.BUNDLE_ID);

		return Platform.getStateLocation(bundle).append(id);

	}

	/**

	 * Helper method for saving resources in designated snippet resource folder.

	 * 

	 * @param snippetId - UID of the snippet that is saving content.

	 * @param pathList - Project relative path list. The resources are copied in the same structure 

	 * 					 in the storage path. e.g. having test.jsp file in project root will result in

	 * 					 test.jsp in the storage root. If the jsp  is in [Project Root]/resources/test.jsp

	 * 					 this will result in [Snippet Storage Root]/resources/test.jsp 

	 * @return

	 */

	public IStatus moveFilesInStorageFolder(IPath snippetStorage, List<IPath> pathList, IProject project){

		File storageFolder = new File(snippetStorage.toOSString());

		if (!storageFolder.exists()){

			if (!storageFolder.mkdirs()){

				return createErrorStatus("Could not create snippet storage folder.", null);

			}

		}

		for (IPath currentPath : pathList) {

			IFile file = project.getFile(currentPath);

			IPath destPath = snippetStorage.append(currentPath);

			File destination = new File(destPath.toOSString());

			if (!destination.getParentFile().exists()){

				if (!destination.getParentFile().mkdirs()){

					return createErrorStatus("Could not create snippet storage folder.", null);

				}

			}	

			try {

				copy(file, destination);

			} catch (FileNotFoundException e) {

				return createErrorStatus(e.getLocalizedMessage(), e);

			} catch (IOException e) {

				return createErrorStatus(e.getLocalizedMessage(), e);

			} catch (CoreException e) {

				return e.getStatus();

			}

		}

		return Status.OK_STATUS;

	}

	public IStatus moveFilesInWorkspace(List<File> fileList, IProject target, IPath storagePath) {

		for (File file : fileList) {

			String fileRelativePath = file.getAbsolutePath().substring(storagePath.toOSString().length());

			IFile ifile = target.getFile(new Path(fileRelativePath));

			try {

				ifile.create(new FileInputStream(file), true, new NullProgressMonitor());

			} catch (FileNotFoundException e) {

				return createErrorStatus(e.getLocalizedMessage(), e);

			} catch (CoreException e) {

				return createErrorStatus(e.getLocalizedMessage(), e);

			}

		}

		return Status.OK_STATUS;

	}

	private void copy(IFile source, File destination) throws FileNotFoundException, IOException, CoreException{

		copy(source.getContents(), new FileOutputStream(destination));

	}	

	private void copy(InputStream in, OutputStream out) throws IOException {

		byte[] buffer = new byte[1024];

		try {

			int n = in.read(buffer);

			while (n > 0) {

				out.write(buffer, 0, n);

				n = in.read(buffer);

			}

		} finally {

			in.close();

			out.close();

		}

	}

	private IStatus createErrorStatus(String msg, Exception e) {

		return new Status(IStatus.ERROR, SnippetsPlugin.BUNDLE_ID, msg, e);

	}	

		String PROVIDER_ID = "snippetProvider";//$NON-NLS-1$

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="org.eclipse.wst.common.snippets" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appInfo>

         <meta.schema plugin="org.eclipse.wst.common.snippets" id="SnippetProvider" name="SnippetProvider"/>

      </appInfo>

      <documentation>

         [Enter description of this extension point.]

      </documentation>

   </annotation>

   <include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>

   <element name="extension">

      <annotation>

         <appInfo>

            <meta.element />

         </appInfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="provider" minOccurs="1" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

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

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

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

            <annotation>

               <documentation>

               </documentation>

               <appInfo>

                  <meta.attribute translatable="true"/>

               </appInfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="provider">

      <complexType>

         <sequence>

            <element ref="enablement"/>

         </sequence>

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

            <annotation>

               <documentation>

               </documentation>

               <appInfo>

                  <meta.attribute kind="java" basedOn=":org.eclipse.wst.common.snippets.ui.ISnippetProvider"/>

               </appInfo>

            </annotation>

         </attribute>

         <attribute name="priority" type="string" use="required">

            <annotation>

               <documentation>

                  0 highest 

100 lowest

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appInfo>

         <meta.section type="since"/>

      </appInfo>

      <documentation>

         [Enter the first release in which this extension point appears.]

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="examples"/>

      </appInfo>

      <documentation>

         [Enter extension point usage example here.]

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="apiinfo"/>

      </appInfo>

      <documentation>

         [Enter API information here.]

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="implementation"/>

      </appInfo>

      <documentation>

         [Enter information about supplied implementation of this extension point.]

      </documentation>

   </annotation>

</schema>

package org.eclipse.wst.common.snippets.internal.dnd;

import org.eclipse.swt.dnd.ByteArrayTransfer;

import org.eclipse.swt.dnd.TransferData;

/**

 * This derived implementation of a byte array transfer short circuits the transfer process

 * so that a local transfer does not serialize the object

 * and hence can and will return the original object, not just a clone.

 * You only really need ever know about {@link #getInstance ObjectTransfer.getInstance()},

 * so that you can include it in when adding drag support to a viewer.

 * See {@link EditingDomainViewerDropAdapter} and {@link ViewerDragAdapter} for more details.

 * <p>

 * As an addded guard, the time is recorded and serialized in javaToNative

 * to that navive to java can ensure that it's returns the value that was really to have been transferred.

 */

public class SnippetTransfer extends ByteArrayTransfer

{

  /**

   * This is the register transfer type name.

   */

  protected static final String TYPE_NAME = "local-transfer-format";

  /**

   * This is the ID that is registered to the name.

   */

  protected static final int TYPE_ID = registerType(TYPE_NAME);

  /**

   * This is initialized and returned by {@link #getInstance}.

   */

  protected static SnippetTransfer instance;

  /**

   * This returns the one instance of this transfer agent.

   */

  public static SnippetTransfer getInstance()

  {

    if (instance == null)

    {

      instance = new SnippetTransfer();

    }

    return instance;

  }

  /**

   * This records the time at which the transfer data was recorded.

   */

  protected long startTime;

  /**

   * This records the data being transferred.

   */

  protected Object object;

  /**

   * This creates an instance; typically you get one from {@link #getInstance}.

   */

  protected SnippetTransfer()

  {

  }

  /**

   * This returns the transfer ids that this agent supports.

   */

  protected int[] getTypeIds() 

  {

    return new int[] { TYPE_ID };

  }

  /**

   * This returns the transfer names that this agent supports.

   */

  public String[] getTypeNames() 

  {

    return new String[] { TYPE_NAME };

  }

  /**

   * This records the object and current time and encodes only the current time into the transfer data.

   */

  public void javaToNative(Object object, TransferData transferData) 

  {

    startTime = System.currentTimeMillis();

    this.object = object;

    if (transferData != null)

    {

      super.javaToNative(String.valueOf(startTime).getBytes(), transferData);

    }

  }

  /**

   * This decodes the time of the transfer and returns the recorded the object if the recorded time and the decoded time match.

   */

  public Object nativeToJava(TransferData transferData) 

  {

    long startTime  = Long.valueOf(new String((byte[])super.nativeToJava(transferData))).longValue();

    return

      this.startTime == startTime ?

        object :

        null;

  }

}

package org.eclipse.wst.common.snippets.ui;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.gef.palette.PaletteEntry;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.wst.common.snippets.core.ISnippetProvider;

import org.eclipse.wst.common.snippets.internal.AbstractSnippetProvider;

import org.eclipse.wst.common.snippets.internal.Logger;

import org.eclipse.wst.common.snippets.internal.palette.SnippetPaletteItem;

import org.eclipse.wst.common.snippets.internal.util.StringUtils;

public class TextSnippetProvider extends AbstractSnippetProvider implements ISnippetProvider {

	@Override

	public SnippetPaletteItem createSnippet(PaletteEntry drawer) throws CoreException {

		SnippetPaletteItem item = super.createSnippet(drawer);

		ITextSelection selection = getTextSelection();

		String selectedText = null;

		try {

			selectedText = getDocument().get(selection.getOffset(), selection.getLength());			

			item.setDescription(StringUtils.firstLineOf(selectedText).trim() + "..."); //$NON-NLS-1$

			item.setContentString(selectedText);

		}

		catch (BadLocationException e) {

			Logger.logException(e);

		}

		return item;

	}

	protected ITextSelection getTextSelection() {

		ITextEditor editor = getTextEditor();

		if (editor != null) {

			ISelection selection = editor.getSelectionProvider().getSelection();

			if (selection instanceof ITextSelection) {

				return (ITextSelection) selection;

			}

		}

		return null;

	}

	protected ITextEditor getTextEditor() {

		ITextEditor editor = null;

		IWorkbenchPart activePart = fEditorPart;

		if (activePart instanceof ITextEditor) {

			editor = (ITextEditor) activePart;

		}

		if (editor == null) {

			editor = (ITextEditor) activePart.getAdapter(ITextEditor.class);

		}

		return editor;

	}

	public boolean isActionEnabled(ISelection selection) {

		boolean enable = false;

		if (selection != null) {

			if (selection instanceof ITextSelection) {

				if (((ITextSelection) selection).getLength() > 0) {

					enable = true;

				}

			}

			else {

				enable = !selection.isEmpty();

			}

		}

		return enable;

	}

	public IDocument getDocument() {

		return getTextEditor().getDocumentProvider().getDocument(fEditorPart.getEditorInput());

	}

	public IStatus saveAdditionalContent(IPath path) {

		return Status.OK_STATUS;

	}

	public ISnippetInsertion getSnippetInstertion() {

		return new DefaultSnippetInsertion();

	}

	public String getId() {

		return TextSnippetProvider.class.getCanonicalName();

	}

}

package org.eclipse.wst.common.snippets.core;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.gef.palette.PaletteEntry;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.ui.IEditorPart;

import org.eclipse.wst.common.snippets.internal.palette.SnippetPaletteItem;

import org.eclipse.wst.common.snippets.ui.ISnippetInsertion;

public interface ISnippetProvider {

	public SnippetPaletteItem createSnippet(PaletteEntry drawer) throws CoreException ;

	public boolean isActionEnabled(ISelection selection);

	public IStatus saveAdditionalContent(IPath path);

	public ISnippetInsertion getSnippetInstertion();

	public String getId();

	public void setEditor(IEditorPart editor);

}

package org.eclipse.wst.common.snippets.internal;

import org.eclipse.core.expressions.EvaluationContext;

import org.eclipse.core.expressions.EvaluationResult;

import org.eclipse.core.expressions.Expression;

import org.eclipse.core.expressions.ExpressionConverter;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.wst.common.snippets.core.ISnippetProvider;

public class SnippetContrubutor {

	public static final String ID_EXTENSION_POINT_PROVIDER  = SnippetsPlugin.BUNDLE_ID + ".SnippetProvider"; //$NON-NLS-1$

	public static final String IMPL  = "impl"; //$NON-NLS-1$

	public static final String PRIO  = "priority"; //$NON-NLS-1$

	public static final String ENABLEMENT  = "enablement"; //$NON-NLS-1$

	private ISnippetProvider provider;

	private IConfigurationElement extPointElement;

	private byte prio;

	private boolean initExecuted = false;

	public SnippetContrubutor(IConfigurationElement extPointElement) {

		super();

		this.extPointElement = extPointElement;

		init0();

	}

	private void init0() {

		if (extPointElement.getAttribute(PRIO) != null){

			try{

				prio = (byte) Integer.parseInt(extPointElement.getAttribute(PRIO));

				if(prio < 0 || prio >100){

					prio = 100;

				}

			}catch (NumberFormatException e){

				prio = 100;

				Logger.logException(e);

			}

		}

	}

	private void init() {

		initExecuted = true;

		try {

			provider = (ISnippetProvider) extPointElement.createExecutableExtension(IMPL);

		} catch (CoreException e) {

			e.printStackTrace();

		}

	}

	public boolean isApplicable(Object o) {

		IConfigurationElement[] configurationElements = extPointElement.getChildren(ENABLEMENT);

		if(configurationElements != null)

			for (IConfigurationElement configurationElement : configurationElements) {

				try {

					return testEnablement(configurationElement,o);

				} catch (CoreException e) {

					//nothing to do testEnablement fails.

					return false;

				}

			}

		return false;

	}

	private boolean testEnablement(IConfigurationElement enable, Object o) throws CoreException{

		Expression exp= ExpressionConverter.getDefault().perform(enable);

		EvaluationContext context = new EvaluationContext(null, o);

		context.setAllowPluginActivation(true);

		return EvaluationResult.TRUE == exp.evaluate(context);

	}

	public ISnippetProvider getProvider() {

		if (!initExecuted){

			init();

		}

		return provider;

	}

	public byte getPrio() {

		return prio;

	}

}

package org.eclipse.wst.common.snippets.internal;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.gef.palette.PaletteEntry;

import org.eclipse.ui.IEditorPart;

import org.eclipse.wst.common.snippets.core.ISnippetProvider;

import org.eclipse.wst.common.snippets.internal.palette.SnippetPaletteItem;

import org.eclipse.wst.common.snippets.internal.palette.SnippetPaletteItemFactory;

public abstract class AbstractSnippetProvider implements ISnippetProvider {

	protected IEditorPart fEditorPart;

	public void setEditor(IEditorPart editor) {

		fEditorPart = editor;

	}

	public SnippetPaletteItem createSnippet(PaletteEntry drawer) throws CoreException {

		SnippetPaletteItem snippet = createSnippetMetadata(drawer);

		return snippet;

	}

	protected SnippetPaletteItem createSnippetMetadata(PaletteEntry drawer) throws CoreException {

		SnippetPaletteItem item = (SnippetPaletteItem) new SnippetPaletteItemFactory().createNewEntry(fEditorPart.getSite().getShell(), drawer);

		item.setProvider(this);

		IStatus status = saveAdditionalContent(item.getStorage());

		if (status!= null && status.getSeverity() == IStatus.ERROR){

			throw new CoreException(status);

		}

		return item;

	}

}

package org.eclipse.wst.common.snippets.internal.util;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IExtension;

import org.eclipse.core.runtime.IExtensionPoint;

import org.eclipse.core.runtime.Platform;

import org.eclipse.ui.IEditorPart;

import org.eclipse.wst.common.snippets.core.ISnippetProvider;

import org.eclipse.wst.common.snippets.internal.SnippetContrubutor;

import org.eclipse.wst.common.snippets.ui.TextSnippetProvider;

public class SnippetProviderManager {

	private static List<ISnippetProvider> getProviders() {

		List<ISnippetProvider> list = new ArrayList<ISnippetProvider>();

		IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(SnippetContrubutor.ID_EXTENSION_POINT_PROVIDER);

		if (extensionPoint != null) {

			IExtension[] extensions = extensionPoint.getExtensions();

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

				IConfigurationElement[] configurationElements = extensions[i].getConfigurationElements();

				for (IConfigurationElement configurationElement : configurationElements) {

					SnippetContrubutor sc = new SnippetContrubutor(configurationElement);

					if (sc.getProvider() != null){

						list.add(sc.getProvider());

					}					

				}

			}

		}

		return list;

	}

	public static ISnippetProvider findProvider(String id) {

		List<ISnippetProvider> providers = getProviders();

		for (ISnippetProvider snippetProvider : providers) {

			if (snippetProvider.getId() != null && snippetProvider.getId().equals(id)){

				return snippetProvider;

			}

		}

		return new TextSnippetProvider();

	}

	public static ISnippetProvider getApplicableProvider(IEditorPart targetEditor) {

		SnippetContrubutor result = null;

		IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(SnippetContrubutor.ID_EXTENSION_POINT_PROVIDER);

		if (extensionPoint != null) {

			IExtension[] extensions = extensionPoint.getExtensions();

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

				IConfigurationElement[] configurationElements = extensions[i].getConfigurationElements();

				for (IConfigurationElement configurationElement : configurationElements) {

					SnippetContrubutor sc = new SnippetContrubutor(configurationElement);

					if (sc.isApplicable(targetEditor)){

						if (result == null){

							result = sc;

						} else if (result.getPrio() > sc.getPrio()){

							result = sc;

						}

					}					

				}

			}

		}

		if (result == null){

			 return null;

		}

		ISnippetProvider provider = result.getProvider();

		provider.setEditor(targetEditor);

		return provider;

	}

}