Attachment #75794 for bug #69581

Lines 7-12 Link Here

(-)ui/org/eclipse/jdt/internal/ui/javaeditor/ClipboardOperationAction.java (-1 / +12 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Dakshinamurthy Karra - TemplatesPage support (bug 69581)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.javaeditor;	12	package org.eclipse.jdt.internal.ui.javaeditor;
12		13
Lines 41-52 Link Here
41	import org.eclipse.jface.text.ITextOperationTarget;	42	import org.eclipse.jface.text.ITextOperationTarget;
42	import org.eclipse.jface.text.ITextSelection;	43	import org.eclipse.jface.text.ITextSelection;
43	import org.eclipse.jface.text.Region;	44	import org.eclipse.jface.text.Region;
		45	import org.eclipse.jface.text.templates.Template;
44		46
45	import org.eclipse.ui.IWorkbenchPartSite;	47	import org.eclipse.ui.IWorkbenchPartSite;
46	import org.eclipse.ui.texteditor.IAbstractTextEditorHelpContextIds;	48	import org.eclipse.ui.texteditor.IAbstractTextEditorHelpContextIds;
47	import org.eclipse.ui.texteditor.ITextEditor;	49	import org.eclipse.ui.texteditor.ITextEditor;
48	import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;	50	import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;
49	import org.eclipse.ui.texteditor.TextEditorAction;	51	import org.eclipse.ui.texteditor.TextEditorAction;
		52	import org.eclipse.ui.texteditor.templates.TemplateTransfer;
		53
		54	import org.eclipse.ui.views.templates.ITemplatesPage;
50		55
51	import org.eclipse.jdt.core.ICompilationUnit;	56	import org.eclipse.jdt.core.ICompilationUnit;
52	import org.eclipse.jdt.core.IJavaElement;	57	import org.eclipse.jdt.core.IJavaElement;
Lines 66-71 Link Here
66	import org.eclipse.jdt.ui.PreferenceConstants;	71	import org.eclipse.jdt.ui.PreferenceConstants;
67		72
68	import org.eclipse.jdt.internal.ui.JavaPlugin;	73	import org.eclipse.jdt.internal.ui.JavaPlugin;
		74	import org.eclipse.jdt.internal.ui.preferences.JavaTemplatesPage;
69		75
70		76
71	/**	77	/**
Lines 489-495 Link Here
489	}	495	}
490	}	496	}
491	} else {	497	} else {
492	fOperationTarget.doOperation(fOperationCode);	498	Template[] templates= (Template[]) clipboard.getContents(TemplateTransfer.getInstance());
		499	if (templates != null) {
		500	JavaTemplatesPage page= (JavaTemplatesPage) editor.getAdapter(ITemplatesPage.class);
		501	page.insertTemplate(templates[0]);
		502	} else
		503	fOperationTarget.doOperation(fOperationCode);
493	}	504	}
494	}	505	}
495		506




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Dakshinamurthy Karra - TemplatesPage support (bug 69581)
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.javaeditor;



import org.eclipse.ui.views.contentoutline.ContentOutline;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
import org.eclipse.ui.views.templates.ITemplatesPage;

import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectNextAction;
import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectPreviousAction;
import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectionAction;
import org.eclipse.jdt.internal.ui.preferences.JavaTemplatesPage;
import org.eclipse.jdt.internal.ui.search.BreakContinueTargetFinder;
import org.eclipse.jdt.internal.ui.search.ExceptionOccurrencesFinder;
import org.eclipse.jdt.internal.ui.search.ImplementOccurrencesFinder;

	protected JavaOutlinePage fOutlinePage;
	/** Outliner context menu Id */
	protected String fOutlinerContextMenuId;
	/** The templates page
     *
     *  @since 3.4
    */
	private JavaTemplatesPage fTemplatesPage;
	
	/**
	 * The editor selection changed listener.
	 *

			return fOutlinePage;
		}

		if (required.equals(ITemplatesPage.class)) {
			return getTemplatesPage();
		}

		if (IEncodingSupport.class.equals(required))
			return fEncodingSupport;


	}

	/**
     *  @since 3.4
     */
	private JavaTemplatesPage getTemplatesPage() {
		if (fTemplatesPage == null) {
			fTemplatesPage= new JavaTemplatesPage(this);

		}
		return fTemplatesPage;
	}

	/**
	 * React to changed selection.
	 *
	 * @since 3.0

	protected void handleCursorPositionChanged() {
		super.handleCursorPositionChanged();
		fCachedSelectedRange= getViewer().getSelectedRange();
		if (fTemplatesPage != null)
			fTemplatesPage.cursorPositionChanged();
	}

	private static boolean isBracket(char character) {




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.preferences;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.corext.template.java.CompilationUnitContextType;
import org.eclipse.jdt.internal.corext.template.java.JavaContext;
import org.eclipse.jdt.internal.corext.template.java.JavaContextType;
import org.eclipse.jdt.internal.corext.template.java.JavaDocContext;
import org.eclipse.jdt.internal.corext.template.java.JavaDocContextType;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.internal.ui.javaeditor.JavaSourceViewer;
import org.eclipse.jdt.internal.ui.text.SimpleJavaSourceViewerConfiguration;
import org.eclipse.jdt.internal.ui.text.template.contentassist.TemplateProposal;
import org.eclipse.jdt.internal.ui.text.template.preferences.TemplateVariableProcessor;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.text.IJavaPartitions;
import org.eclipse.jdt.ui.text.JavaTextTools;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewerExtension;
import org.eclipse.jface.text.ITextViewerExtension5;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.text.templates.ContextTypeRegistry;
import org.eclipse.jface.text.templates.DocumentTemplateContext;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.text.templates.TemplateContextType;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.texteditor.templates.TemplatesPage;
import org.eclipse.ui.views.templates.ITemplatesPage;

/**
 * A TemplatesPage implementation for JavaEditor
 * 
 * @since 3.4
 */
public class JavaTemplatesPage extends TemplatesPage implements ITemplatesPage {

	private final class JavaDocContextExtension extends JavaDocContext {
		private final Template fTemplate;
		private final boolean fOverrideGetKey;

		private JavaDocContextExtension(IDocument document, Position completionPosition, Template template, boolean overrideGetKey) {
			super(CONTEXT_REGISTRY.getContextType(template.getContextTypeId()),
						document,
						completionPosition, JavaCore.createCompilationUnitFrom(((FileEditorInput) fEditor.getEditorInput()).getFile()));
			fTemplate = template;
			fOverrideGetKey = overrideGetKey;
		}

		public String getKey() {
			String key = super.getKey();
			if (!fOverrideGetKey)
				return key ;
			try {
				int offset ;
				if (key.equals("") && (offset = getCompletionOffset()) > 0 && Character.isWhitespace(getDocument().getChar(offset - 1))) //$NON-NLS-1$
					return fTemplate.getName().substring(0, 1);
			} catch (BadLocationException e) {
			}
			return key ;
		}
	}

	private final class JavaContextExtension extends JavaContext {
		private final boolean fOverrideGetKey;
		private final Template fTemplate;

		private JavaContextExtension(IDocument document, Position completionPosition,
				Template template, boolean overrideGetKey) {
			super(CONTEXT_REGISTRY.getContextType(template.getContextTypeId()),
					document,
					completionPosition, JavaCore.createCompilationUnitFrom(((FileEditorInput) fEditor.getEditorInput()).getFile()));
			fOverrideGetKey = overrideGetKey;
			fTemplate = template;
		}

		public String getKey() {
			String key = super.getKey();
			if (!fOverrideGetKey)
				return key ;
			try {
				int offset ;
				if (key.equals("") && (offset = getCompletionOffset()) > 0 && !isTempalteNamePart(getDocument().getChar(offset - 1))) //$NON-NLS-1$
					return fTemplate.getName().substring(0, 1);
			} catch (BadLocationException e) {
			}
			return key ;
		}

		/**
		 * Copied from JavaContext
		 * @param ch
		 * @return true if ch can be a part of a templates name
		 */
		private boolean isTempalteNamePart(char ch) {
			return !Character.isWhitespace(ch) && ch != '(' && ch != ')' && ch != '{' && ch != '}' && ch != ';';
		}
	}

	private static final ContextTypeRegistry CONTEXT_REGISTRY= JavaPlugin.getDefault().getTemplateContextRegistry();
	private TemplateVariableProcessor fTemplateProcessor;
	private final JavaEditor fEditor;
	private String fJavaDocId;
	private String fJavaId;
	private String fCurrentId;
	private int fCachedOffset;
	private boolean fCachedResult;
	private Point fCachedPosition;

	/**
	 * @param javaEditor
	 */
	public JavaTemplatesPage(JavaEditor javaEditor) {
		super(JavaPlugin.getDefault().getTemplateStore(), JavaPlugin.getDefault().getPreferenceStore(), CONTEXT_REGISTRY);
		fEditor= javaEditor;
		fJavaDocId= new JavaDocContextType().getId();
		fJavaId= new JavaContextType().getId();
		fTemplateProcessor= new TemplateVariableProcessor();
		cursorPositionChanged();
		setupEditorDropTarget(fEditor.getSite(), fEditor.getViewer().getTextWidget());
	}

	public void dispose() {
		super.dispose();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#editTemplate(org.eclipse.jface.text.templates.Template, boolean, boolean)
	 */
	protected Template editTemplate(Template template, boolean edit, boolean isNameModifiable) {
		EditTemplateDialog dialog= new EditTemplateDialog(getShell(), template, edit, isNameModifiable, CONTEXT_REGISTRY);
		if (dialog.open() == Window.OK) {
			return dialog.getTemplate();
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#createViewer(org.eclipse.swt.widgets.Composite)
	 */
	protected SourceViewer createViewer(Composite parent) {
		IDocument document= new Document();
		JavaTextTools tools= JavaPlugin.getDefault().getJavaTextTools();
		tools.setupJavaDocumentPartitioner(document, IJavaPartitions.JAVA_PARTITIONING);
		IPreferenceStore store= JavaPlugin.getDefault().getCombinedPreferenceStore();
		SourceViewer viewer= new JavaSourceViewer(parent, null, null, false, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL, store);
		SimpleJavaSourceViewerConfiguration configuration= new SimpleJavaSourceViewerConfiguration(tools.getColorManager(), store, null, IJavaPartitions.JAVA_PARTITIONING, false);
		viewer.configure(configuration);
		viewer.setEditable(false);
		viewer.setDocument(document);

		Font font= JFaceResources.getFont(PreferenceConstants.EDITOR_TEXT_FONT);
		viewer.getTextWidget().setFont(font);
		new JavaSourcePreviewerUpdater(viewer, configuration, store);

		Control control= viewer.getControl();
		GridData data= new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.FILL_VERTICAL);
		control.setLayoutData(data);

		return viewer;
	}


	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#updateViewerInput(org.eclipse.jface.text.templates.Template)
	 */
	protected void updateViewerInput(Template template) {
		SourceViewer viewer= getViewer();

		String contextId= template.getContextTypeId();
		TemplateContextType type= CONTEXT_REGISTRY.getContextType(contextId);
		fTemplateProcessor.setContextType(type);

		IDocument doc= viewer.getDocument();

		String start= null;
		if ("javadoc".equals(contextId)) { //$NON-NLS-1$
			start= "/**" + doc.getLegalLineDelimiters()[0]; //$NON-NLS-1$
		} else
			start= ""; //$NON-NLS-1$

		doc.set(start + template.getPattern());
		int startLen= start.length();
		viewer.setDocument(doc, startLen, doc.getLength() - startLen);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#getPreferencePageId()
	 */
	protected String getPreferencePageId() {
		return "org.eclipse.jdt.ui.preferences.JavaTemplatePreferencePage"; //$NON-NLS-1$
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#insertTemplate(org.eclipse.jface.text.templates.Template)
	 */
	public void insertTemplate(Template template) {
		if (!fEditor.validateEditorInputState())
			return ;
		ISourceViewer contextViewer= fEditor.getViewer();
		ITextSelection textSelection= (ITextSelection) contextViewer.getSelectionProvider().getSelection();
		IDocument document = fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput());
		if ( !isValidTemplate(document, template, textSelection.getOffset(), textSelection.getLength()))
			return;
		beginCompoundChange(contextViewer);
		/*
		 * The Editor checks whether a completion for a word exists before it allows for the template to be
		 * applied. We pickup the current text at the selection position and replace it with the first char
		 * of the template name for this to succeed.
		 * Another advantage by this method is that the template replaces the selected text provided the
		 * selection by itself is not used in the template pattern.
		 */
		String savedText;
		try {
			savedText= document.get(textSelection.getOffset(), textSelection.getLength());
			if (savedText.length() == 0) {
				String prefix = getIdentifierPart(document, template, textSelection.getOffset(), textSelection.getLength());
				if (prefix.length() > 0 && !template.getName().startsWith(prefix.toString())) {
					return;
				}
				if (prefix.length() > 0) {
					contextViewer.setSelectedRange(textSelection.getOffset() - prefix.length(), prefix.length());
					textSelection= (ITextSelection) contextViewer.getSelectionProvider().getSelection();
				}
			}
			document.replace(textSelection.getOffset(), textSelection.getLength(), template.getName().substring(0, 1));
		} catch (BadLocationException e) {
			endCompoundChange(contextViewer);
			return;
		}
		Position position= new Position(textSelection.getOffset() + 1, 0);
		Region region= new Region(textSelection.getOffset() + 1, 0);
		contextViewer.getSelectionProvider().setSelection(new TextSelection(textSelection.getOffset(), 1));
		ICompilationUnit compilationUnit= JavaCore.createCompilationUnitFrom(((FileEditorInput) fEditor.getEditorInput()).getFile());

		TemplateContextType type= CONTEXT_REGISTRY.getContextType(template.getContextTypeId());
		DocumentTemplateContext context= ((CompilationUnitContextType) type).createContext(document, position, compilationUnit);
		context.setVariable("selection", savedText); //$NON-NLS-1$
		if (context.getKey().length() == 0) {
			try {
				document.replace(textSelection.getOffset(), 1, savedText);
			} catch (BadLocationException e) {
				endCompoundChange(contextViewer);
				return;
			}
		}
		TemplateProposal proposal= new TemplateProposal(template, context, region, null);
		fEditor.getSite().getPage().activate(fEditor);
		proposal.apply(fEditor.getViewer(), ' ', 0, region.getOffset());
		endCompoundChange(contextViewer);
	}

	/**
	 * Undomanager - end compound change
	 * @param viewer
	 */
	private void endCompoundChange(ISourceViewer viewer) {
		if (viewer instanceof ITextViewerExtension)
			((ITextViewerExtension)viewer).getRewriteTarget().endCompoundChange();
	}

	/**
	 * Undomanager - begin a compound change
	 * @param viewer
	 */
	private void beginCompoundChange(ISourceViewer viewer) {
		if (viewer instanceof ITextViewerExtension)
			((ITextViewerExtension)viewer).getRewriteTarget().beginCompoundChange();
	}

	/**
	 * Invoked by the editor whenever the caret position is updated
	 */
	public void cursorPositionChanged() {
		Point selectedRange= fEditor.getViewer().getSelectedRange();
		int cursor= selectedRange.x + selectedRange.y;
		String partition;
		try {
			IDocument document = fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput());
			partition= TextUtilities.getContentType(document, IJavaPartitions.JAVA_PARTITIONING, cursor, true);
		} catch (BadLocationException e) {
			return;
		}
		String id= fJavaId;
		if (partition.equals(IJavaPartitions.JAVA_DOC))
			id= fJavaDocId;
		if (!id.equals(fCurrentId)) {
			fCurrentId= id;
			contextTypeChanged(new String[] { id });
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#isValidTempalteForPosition(org.eclipse.jface.text.templates.Template, int, int)
	 */
	protected boolean isValidTemplateForPosition(Template template, int x, int y) {
		StyledText textWidget= fEditor.getViewer().getTextWidget();
		IDocument document = fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput());
		try {
			Point point= new Point(x,y);
			if (point.equals(fCachedPosition))
				return fCachedResult;
			fCachedPosition = point ;
			int offset= getOffset(document, textWidget, textWidget.toControl(x, y));
			if (fCachedOffset == offset)
				return fCachedResult;
			fCachedOffset= offset;
			if (isValidTemplate(document, template, offset, 0))
				return fCachedResult= true;
		} catch (BadLocationException e) {
		}
		return fCachedResult= false;
	}

	/**
	 * Get the document relative offset from the textwidget relative point
	 * 
	 * @param document
	 * @param textWidget
	 * @param point
	 * @return the offset
	 * @throws BadLocationException
	 */
	private int getOffset(IDocument document, StyledText textWidget, Point point) throws BadLocationException {
		ITextViewerExtension5 ext= (ITextViewerExtension5) fEditor.getViewer();
		try {
			return ext.widgetOffset2ModelOffset(textWidget.getOffsetAtLocation(point));
		} catch (IllegalArgumentException e) {
			int docLineIndex= ext.widgetLine2ModelLine(textWidget.getLineIndex(point.y));
			String lineDelimiter= document.getLineDelimiter(docLineIndex);
			int delimLength= lineDelimiter == null ? 0 : lineDelimiter.length();
			return document.getLineOffset(docLineIndex) + document.getLineLength(docLineIndex) - delimLength;
		}
	}

	/**
	 * Check whether the template is valid for the given offset
	 * @param document 
	 * @param template
	 * @param offset
	 * @param length 
	 * @return true if the template is valid
	 */
	private boolean isValidTemplate(IDocument document, Template template, int offset, int length) {
		try {
			if (!getContextId(document, offset).equals(template.getContextTypeId()))
				return false ;
		} catch (BadLocationException e) {
			return false ;
		}
		DocumentTemplateContext context = getContextExtension(document, template, offset, length, true);
		return context.canEvaluate(template);
	}

	/**
	 * Get context extension
	 * 
	 * @param document
	 * @param template
	 * @param offset
	 * @param length
	 * @param overrideGetKey
	 * @return the contextextension
	 */
	private DocumentTemplateContext getContextExtension(IDocument document, Template template, final int offset,
			int length, boolean overrideGetKey) {
		DocumentTemplateContext context;
		if (template.getContextTypeId().equals(fJavaId)) {
			context = new JavaContextExtension(document, new Position(offset, length), template, overrideGetKey);
		} else {
			context = new JavaDocContextExtension(document, new Position(offset, length),template, overrideGetKey);
		}
		return context;
	}

	/**
	 * Get the context id for at the given offset
	 * 
	 * @param document 
	 * @param offset
	 * @return the context id
	 * @throws BadLocationException
	 */
	private String getContextId(IDocument document, int offset) throws BadLocationException {
		String partition= TextUtilities.getContentType(document, IJavaPartitions.JAVA_PARTITIONING, offset, true);
		String id= fJavaId;
		if (partition.equals(IJavaPartitions.JAVA_DOC))
			id= fJavaDocId;
		return id;
	}

	/**
	 * Get the java identifier terminated at the given offset
	 * @param document 
	 * @param template 
	 * @param offset
	 * @param length 
	 * @return the identifier part
	 * @throws BadLocationException
	 */
	private String getIdentifierPart(IDocument document, Template template, int offset, int length) throws BadLocationException {
		return getContextExtension(document, template, offset, length, false).getKey();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#isEditorModifiable()
	 */
	protected boolean isEditorModifiable() {
		return fEditor.isEditorInputModifiable();
	}
}

Lines 7-16 Link Here

(-)plugin.properties (-1 / +2 lines)
7	#	7	#
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
		10	# Dakshinamurthy Karra - Templates support (bug 69581)
10	###############################################################################	11	###############################################################################
11	pluginName= Views	12	pluginName= Views
12	providerName= Eclipse.org	13	providerName= Eclipse.org
13		14
14	Views.PropertySheet = Properties	15	Views.PropertySheet = Properties
15	Views.ContentOutline = Outline	16	Views.ContentOutline = Outline
16		17	Views.Templates = Templates

Lines 18-23 Link Here

(-)plugin.xml (+7 lines)
18	class="org.eclipse.ui.views.contentoutline.ContentOutline"	18	class="org.eclipse.ui.views.contentoutline.ContentOutline"
19	id="org.eclipse.ui.views.ContentOutline">	19	id="org.eclipse.ui.views.ContentOutline">
20	</view>	20	</view>
		21	<view
		22	name="%Views.Templates"
		23	icon="$nl$/icons/full/eview16/templates.gif"
		24	category="org.eclipse.ui"
		25	class="org.eclipse.ui.views.templates.Templates"
		26	id="org.eclipse.ui.views.Templates">
		27	</view>
21	</extension>	28	</extension>
22		29
23	</plugin>	30	</plugin>

Lines 11-17 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
11	org.eclipse.ui.internal.views.contentoutline;x-internal:=true,	11	org.eclipse.ui.internal.views.contentoutline;x-internal:=true,
12	org.eclipse.ui.internal.views.properties;x-internal:=true,	12	org.eclipse.ui.internal.views.properties;x-internal:=true,
13	org.eclipse.ui.views.contentoutline,	13	org.eclipse.ui.views.contentoutline,
14	org.eclipse.ui.views.properties	14	org.eclipse.ui.views.properties,
		15	org.eclipse.ui.views.templates
15	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",	16	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
16	org.eclipse.help;bundle-version="[3.2.0,4.0.0)",	17	org.eclipse.help;bundle-version="[3.2.0,4.0.0)",
17	org.eclipse.ui;bundle-version="[3.2.0,4.0.0)"	18	org.eclipse.ui;bundle-version="[3.2.0,4.0.0)"




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.internal.views.templates;

import org.eclipse.osgi.util.NLS;

/**
 * TemplatesMessages is the message class for the messages used in the templates view.
 *
 */
public class TemplatesMessages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.ui.internal.views.templates.TemplatesMessages"; //$NON-NLS-1$
	
	// Default message for an empty templates view
	public static String Templates_defaultMessage;
	static {
		// initialize resource bundle
		NLS.initializeMessages(BUNDLE_NAME, TemplatesMessages.class);
	}

	private TemplatesMessages() {
	}
}

Added Link Here

(-)src/org/eclipse/ui/internal/views/templates/TemplatesMessages.properties (+11 lines)
1	###############################################################################
2	# Copyright (c) 2000, 2007 Dakshinamurthy Karra 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	# Dakshinamurthy Karra - initial API and implementation
10	###############################################################################
11	Templates_defaultMessage=No templates available for this editor




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/

package org.eclipse.ui.views.templates;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.views.ViewsPlugin;
import org.eclipse.ui.internal.views.templates.TemplatesMessages;
import org.eclipse.ui.part.IContributedContentsView;
import org.eclipse.ui.part.IPage;
import org.eclipse.ui.part.MessagePage;
import org.eclipse.ui.part.PageBook;
import org.eclipse.ui.part.PageBookView;

/**
 * Main class for the Templates View.
 * <p>
 * This standard view has id <code>"org.eclipse.ui.views.TemplatesView"</code>.
 * </p>
 * When a <b>templates view</b> notices an editor being activated, it 
 * asks the editor whether it has a <b>template page</b> to include
 * in the templates view. This is done using <code>getAdapter</code>:
 * <pre>
 * IEditorPart editor = ...;
 * ITemplatePage templatePage = (ITemplatePage) editor.getAdapter(ITemplatePage.class);
 * if (templatePage != null) {
 *    // editor wishes to contribute templatePage to templates view
 * }
 * </pre>
 * If the editor supports a templates page, the editor instantiates
 * and configures the page, and returns it. This page is then added to the 
 * templates view (a pagebook which presents one page at a time) and 
 * immediately made the current page (the templates view need not be
 * visible). If the editor does not support a template page, the templates
 * view shows a special default page which makes it clear to the user
 * that the templates view is disengaged. When the templates view notices a
 * different editor being activated, it flips to the editor's corresponding
 * template page. When the templates view notices an editor being
 * closed, it may destroy the editor's corresponding content outline page.
 * </p>
 * <p>
 * The workbench will automatically instantiate this class when a templates
 * view is needed for a workbench window. This class was not intended
 * to be instantiated or subclassed by clients.
 * </p>
 *
 * @since 3.4
 */
public class Templates extends PageBookView {
    /**
     * The plugin prefix.
     */
    public static final String PREFIX = PlatformUI.PLUGIN_ID + "."; //$NON-NLS-1$

    /**
     * Help context id used for the content outline view
     * (value <code>"org.eclipse.ui.content_outline_context"</code>).
     */
    public static final String TEMPLATES_VIEW_HELP_CONTEXT_ID = PREFIX
            + "templates_view_context";//$NON-NLS-1$

    /**
     * Message to show on the default page.
     */
    private String defaultText = TemplatesMessages.Templates_defaultMessage; 

    /**
     * Creates a content outline view with no content outline pages.
     */
    public Templates() {
        super();
    }

    /* (non-Javadoc)
     * Method declared on PageBookView.
     */
    protected IPage createDefaultPage(PageBook book) {
        MessagePage page = new MessagePage();
        initPage(page);
        page.createControl(book);
        page.setMessage(defaultText);
        return page;
    }

    /**
     * The <code>PageBookView</code> implementation of this <code>IWorkbenchPart</code>
     * method creates a <code>PageBook</code> control with its default page showing.
     */
    public void createPartControl(Composite parent) {
        super.createPartControl(parent);
        PlatformUI.getWorkbench().getHelpSystem().setHelp(getPageBook(),
                TEMPLATES_VIEW_HELP_CONTEXT_ID);
    }

    /* (non-Javadoc)
     * Method declared on PageBookView.
     */
    protected PageRec doCreatePage(IWorkbenchPart part) {
        // Try to get template page.
        Object obj = ViewsPlugin.getAdapter(part, ITemplatesPage.class, false);
        if (obj instanceof ITemplatesPage) {
            ITemplatesPage page = (ITemplatesPage) obj;
			initPage(page);
            page.createControl(getPageBook());
            return new PageRec(part, page);
        }
        // There is no template page
        return null;
    }

    /* (non-Javadoc)
     * Method declared on PageBookView.
     */
    protected void doDestroyPage(IWorkbenchPart part, PageRec rec) {
        ITemplatesPage page = (ITemplatesPage) rec.page;
        page.dispose();
        rec.dispose();
    }

    /* (non-Javadoc)
     * Method declared on IAdaptable.
     */
    public Object getAdapter(Class key) {
        if (key == IContributedContentsView.class) {
			return new IContributedContentsView() {
                public IWorkbenchPart getContributingPart() {
                    return getContributingEditor();
                }
            };
		}
        return super.getAdapter(key);
    }

    /* (non-Javadoc)
     * Method declared on PageBookView.
     */
    protected IWorkbenchPart getBootstrapPart() {
        IWorkbenchPage page = getSite().getPage();
        if (page != null) {
			return page.getActiveEditor();
		}

        return null;
    }

    /**
     * Returns the editor which contributed the current 
     * page to this view.
     *
     * @return the editor which contributed the current page
     * or <code>null</code> if no editor contributed the current page
     */
    private IWorkbenchPart getContributingEditor() {
        return getCurrentContributingPart();
    }

    /* (non-Javadoc)
     * Method declared on PageBookView.
     * We only want to track editors.
     */
    protected boolean isImportant(IWorkbenchPart part) {
        //We only care about editors
        return (part instanceof IEditorPart);
    }

    /* (non-Javadoc)
     * Method declared on IViewPart.
     * Treat this the same as part activation.
     */
    public void partBroughtToTop(IWorkbenchPart part) {
        partActivated(part);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.views.templates;

import org.eclipse.ui.part.IPageBookViewPage;

/**
 * Interface for a template page. This interface defines
 * the minimum requirement for pages within the templates view, namely
 * they must be pages (implement <code>IPageBookViewPage</code>).
 *
 * @see TemplatesView
 * @since 3.4
 */
public interface ITemplatesPage extends IPageBookViewPage {
}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Dakshinamurthy Karra - TemplatesPage support (bug 69581)
 *******************************************************************************/
package org.eclipse.ui.texteditor.templates;


final class TextEditorTemplateMessages extends NLS {

	private static final String BUNDLE_NAME= TextEditorTemplateMessages.class.getName();

	private TextEditorTemplateMessages() {
		// Do not instantiate
	}

	// TemplatesView
	public static String TemplatesPage_column_context;
	public static String TemplatesPage_column_description;
	public static String TemplatesPage_column_name;
	public static String TemplatesPage_insert;
	public static String TemplatesPage_edit;
	public static String TemplatesPage_preference_page;
	public static String TemplatesPage_link_to_editor;
	public static String TemplatesPage_collapse_expand;
	public static String TemplatesPage_new;
	public static String TemplatesPage_remove;
	public static String TemplatesPage_show_disabled;
	public static String TemplatesPage_show_new_dialog;
	public static String TemplatesPage_insert_tooltip;
	public static String TemplatesPage_edit_tooltip;
	public static String TemplatesPage_preference_page_tooltip;
	public static String TemplatesPage_link_to_editor_tooltip;
	public static String TemplatesPage_collapse_expand_tooltip;
	public static String TemplatesPage_new_tooltip;
	public static String TemplatesPage_remove_tooltip;
	public static String TemplatesPage_show_disabled_tooltip;
	public static String TemplatesPage_show_new_dialog_tooltip;
	public static String TemplatesPage_preview;
	public static String TemplatesPage_question_create_new_message;
	public static String TemplatesPage_question_create_new_title;
	public static String TemplatesPage_save_error_message;
	public static String TemplatesPage_snippet;
	public static String TemplatesPage_paste_description;
	public static String TemplatesPage_context_description;
	public static String TemplatesPage_context_label;
	public static String TemplatesPage_remove_message;
	public static String TemplatesPage_remove_title;
	public static String TemplatesPage_disabled_message;

	// TemplatePreferencePage
	public static String TemplatePreferencePage_error_import;
	public static String TemplatePreferencePage_error_export;
	public static String TemplatePreferencePage_error_read_title;




#
# Contributors:
#     IBM Corporation - initial API and implementation
#     Dakshinamurthy Karra - TemplatesPage support (bug 69581)
###############################################################################

# templates page (view)
TemplatesPage_collapse_expand=Collapse or Expand
TemplatesPage_column_context=Context
TemplatesPage_column_description=Description
TemplatesPage_save_error_message=Error Saving the Templates
TemplatesPage_column_name=Name
TemplatesPage_edit=&Edit...
TemplatesPage_insert=&Insert...
TemplatesPage_preference_page=&Preference Page...
TemplatesPage_paste_description=Pasted from editor
TemplatesPage_link_to_editor=Link to Editor
TemplatesPage_new=&New...
TemplatesPage_preview=Preview
TemplatesPage_snippet=snippet
TemplatesPage_question_create_new_message= The name of the template has been changed. Click 'Yes' to create an additional template with the new name or 'No' to rename the existing one.
TemplatesPage_context_description=
TemplatesPage_context_label={0} ({1} templates, {2} hidden)
TemplatesPage_remove_title=Removing Templates
TemplatesPage_remove_message=Are you sure you want to remove the selected templates?
TemplatesPage_question_create_new_title= Edit Template
TemplatesPage_remove=&Remove
TemplatesPage_show_disabled=&Show Hidden
TemplatesPage_show_new_dialog=S&how New Dialog on Drop
TemplatesPage_insert_tooltip=Insert into editor
TemplatesPage_edit_tooltip=Edit the template
TemplatesPage_preference_page_tooltip=Show preference page
TemplatesPage_link_to_editor_tooltip=Link with editor
TemplatesPage_collapse_expand_tooltip=Collapse or expand groups
TemplatesPage_new_tooltip=Create a new template
TemplatesPage_remove_tooltip=Remove the template
TemplatesPage_show_disabled_tooltip=Show hidden templates
TemplatesPage_show_new_dialog_tooltip=Show new dialog
TemplatesPage_disabled_message=\ (hidden)

# preference page
TemplatePreferencePage_error_import=Failed to import templates.
TemplatePreferencePage_error_export=Failed to export templates.

Lines 7-12 Link Here

(-)src/org/eclipse/ui/texteditor/templates/TemplatePreferencePage.java (-1 / +2 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Dakshinamurthy Karra - bug 69581
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.ui.texteditor.templates;	12	package org.eclipse.ui.texteditor.templates;
12		13
Lines 134-140 Link Here
134	*	135	*
135	* @since 3.3	136	* @since 3.3
136	*/	137	*/
137	protected static class EditTemplateDialog extends StatusDialog {	138	public static class EditTemplateDialog extends StatusDialog {
138		139
139	private class TextViewerAction extends Action implements IUpdate {	140	private class TextViewerAction extends Action implements IUpdate {
140		141




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.texteditor.templates;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.TreeColumnLayout;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.text.source.SourceViewerConfiguration;
import org.eclipse.jface.text.templates.ContextTypeRegistry;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.text.templates.TemplateContextType;
import org.eclipse.jface.text.templates.persistence.TemplatePersistenceData;
import org.eclipse.jface.text.templates.persistence.TemplateStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ColumnPixelData;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableColorProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.ViewForm;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSourceAdapter;
import org.eclipse.swt.dnd.DragSourceEvent;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.dialogs.PreferencesUtil;
import org.eclipse.ui.dnd.IDragAndDropService;
import org.eclipse.ui.internal.texteditor.NLSUtility;
import org.eclipse.ui.internal.texteditor.TextEditorPlugin;
import org.eclipse.ui.part.Page;
import org.eclipse.ui.texteditor.templates.TemplatePreferencePage.EditTemplateDialog;

/**
 * An abstract base class for template pages for use with TextEditor and JFace
 * {@link Template}.
 * <p>
 * Clients who are defining an editor may elect to provide a corresponding
 * templates page. This templates page will be presented to the user via the
 * Templates View (the user decides whether their workbench window contains this
 * view) whenever that editor is active. This class should be subclassed.
 * </p>
 * <p>
 * Internally, a TemplatesPage uses the template store to display different
 * categories. A link to editor mode on the templates page allows to filtering
 * of the categories to only that are supported in this context.
 * </p>
 * @since 3.4
 */
public abstract class TemplatesPage extends Page {

	/**
	 * Sashform size
	 */
	private static final String SASH_SIZE_PREF_ID = TextEditorPlugin.PLUGIN_ID
			+ ".templates.templatesPage.sashSize"; //$NON-NLS-1$
	/**
	 * Tree columns widths
	 */
	private static final String COLUMN_NAME_WIDTH_PREF_ID = TextEditorPlugin.PLUGIN_ID
			+ ".templates.templatesPage.nameWidth"; //$NON-NLS-1$
	private static final String COLUMN_DESCRIPTION_WIDTH_PREF_ID = TextEditorPlugin.PLUGIN_ID
			+ ".templates.templatesPage.descriptionWidth"; //$NON-NLS-1$
	/**
	 * Link to editor action setting
	 */
	private static final String LINK_ACTION_PREF_ID = TextEditorPlugin.PLUGIN_ID
			+ ".templates.templatesPage.linkAction"; //$NON-NLS-1$
	/**
	 * Show disabled actions setting
	 */
	private static final String SHOW_DISABLED_ACTION_PREF_ID = TextEditorPlugin.PLUGIN_ID
			+ ".templates.templatesPage.showDisabledAction"; //$NON-NLS-1$
	/**
	 * Show new dialog on drop setting
	 */
	private static final String SHOW_NEW_DIALOG_ACTION_PREF_ID = TextEditorPlugin.PLUGIN_ID
			+ ".templates.templatesPage.showNewDialogAction"; //$NON-NLS-1$;

	/**
	 * The ID for the popup menu for this templates page
	 */
	private static final String POPUP_MENU_ID = "org.eclipse.ui.texteditor.templates.PopupMenu"; //$NON-NLS-1$

	/**
	 * Drop support for the editor linked to this page. When a user drops a
	 * template into the active editor, the template is applied at the drop
	 * position.
	 */
	private final class EditorDropTarget extends DropTargetAdapter {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.swt.dnd.DropTargetAdapter#dragEnter(org.eclipse.swt.dnd.DropTargetEvent)
		 */
		public void dragEnter(DropTargetEvent event) {
			if (event.detail == DND.DROP_DEFAULT)
				event.detail = DND.DROP_COPY;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.swt.dnd.DropTargetAdapter#dragOperationChanged(org.eclipse.swt.dnd.DropTargetEvent)
		 */
		public void dragOperationChanged(DropTargetEvent event) {
			if (event.detail == DND.DROP_DEFAULT)
				event.detail = DND.DROP_COPY;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.swt.dnd.DropTargetAdapter#dragOver(org.eclipse.swt.dnd.DropTargetEvent)
		 */
		public void dragOver(DropTargetEvent event) {
			event.feedback |= DND.FEEDBACK_SCROLL;
			if (!isEditorModifiable()) {
				event.detail = DND.DROP_NONE;
				return;
			}
			if (isValidTemplateForPosition(getSelectedTemplate(), event.x, event.y)) {
				event.detail = DND.DROP_COPY;
				return;
			}
			event.detail = DND.DROP_NONE;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.swt.dnd.DropTargetAdapter#drop(org.eclipse.swt.dnd.DropTargetEvent)
		 */
		public void drop(DropTargetEvent event) {
			insertTemplate(getSelectedTemplate());
		}
	}

	/**
	 * Comparator for the viewer. Sorts the templates by name and then
	 * description and context types by names.
	 */
	private static final class TemplateViewerComparator extends ViewerComparator {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer,
		 *      java.lang.Object, java.lang.Object)
		 */
		public int compare(Viewer viewer, Object object1, Object object2) {
			if ((object1 instanceof TemplatePersistenceData)
					&& (object2 instanceof TemplatePersistenceData)) {
				Template left = ((TemplatePersistenceData) object1).getTemplate();
				Template right = ((TemplatePersistenceData) object2).getTemplate();
				int result = left.getName().compareToIgnoreCase(right.getName());
				if (result != 0)
					return result;
				return left.getDescription().compareToIgnoreCase(right.getDescription());
			}
			if ((object1 instanceof TemplateContextType)
					&& (object2 instanceof TemplateContextType)) {
				return ((TemplateContextType) object1).getName().compareToIgnoreCase(
						((TemplateContextType) object1).getName());
			}
			return super.compare(viewer, object1, object2);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ViewerComparator#isSorterProperty(java.lang.Object,
		 *      java.lang.String)
		 */
		public boolean isSorterProperty(Object element, String property) {
			return true;
		}
	}

	/**
	 * Label provider for templates.
	 */
	private class TemplateLabelProvider extends LabelProvider implements ITableLabelProvider, ITableColorProvider {

		private final Color fgcDisabled = getShell().getDisplay().getSystemColor(SWT.COLOR_GRAY);
		private final Color fgcEnabled = getShell().getDisplay().getSystemColor(SWT.COLOR_WIDGET_FOREGROUND);
		private final Image fContextImage = TemplatesViewImages.getImage(ITemplatesViewImageConstants.IMG_OBJ_CONTEXT);
		private final Image fTemplateImage = TemplatesViewImages.getImage(ITemplatesViewImageConstants.IMG_OBJ_TEMPLATE);
		
		/*
		 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object,
		 *      int)
		 */
		public Image getColumnImage(Object element, int columnIndex) {
			if (columnIndex != 0)
				return null ;
			if (element instanceof TemplateContextType)
				return fContextImage ;
			return fTemplateImage;
		}

		/*
		 * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object,
		 *      int)
		 */
		public String getColumnText(Object element, int columnIndex) {
			if (element instanceof TemplatePersistenceData)
				return getTemplateColumnText((TemplatePersistenceData) element,
						columnIndex);
			return getContextColumnText((TemplateContextType) element, columnIndex);
		}

		/**
		 * Return the column text for a template
		 * 
		 * @param data
		 * @param columnIndex
		 * @return the column text
		 */
		private String getTemplateColumnText(TemplatePersistenceData data, int columnIndex) {
			switch (columnIndex) {
			case 0:
				return data.getTemplate().getName();
			case 1:
				String disabledMessage = "" ; //$NON-NLS-1$
				if (!data.isEnabled())
					disabledMessage = TextEditorTemplateMessages.TemplatesPage_disabled_message;
				return data.getTemplate().getDescription() + disabledMessage;
			default:
				return ""; //$NON-NLS-1$
			}
		}

		/**
		 * Return the column text for a context
		 * 
		 * @param contextType
		 * @param columnIndex
		 * @return the column text
		 */
		private String getContextColumnText(TemplateContextType contextType, int columnIndex) {
			switch (columnIndex) {
			case 0:
				String id = contextType.getId();
				int count_enabled = 0;
				int count_disabled = 0 ;
				TemplatePersistenceData[] templateData = fTemplateStore.getTemplateData(false);
				for (int i = 0; i < templateData.length; i++) {
					if (id.equals(templateData[i].getTemplate().getContextTypeId())) {
						if (templateData[i].isEnabled())
							count_enabled++;
						else
							count_disabled++;
					}
				}
				String msg = NLSUtility.format(TextEditorTemplateMessages.TemplatesPage_context_label, 
						new Object[] { contextType.getName(), new Integer(count_enabled+count_disabled), new Integer(count_disabled) });
				return msg;
			case 1:
				return TextEditorTemplateMessages.TemplatesPage_context_description;
			default:
				return ""; //$NON-NLS-1$
			}
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ITableColorProvider#getBackground(java.lang.Object, int)
		 */
		public Color getBackground(Object element, int columnIndex) {
			return null ;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ITableColorProvider#getForeground(java.lang.Object, int)
		 */
		public Color getForeground(Object element, int columnIndex) {
			if (element instanceof TemplatePersistenceData) {
				TemplatePersistenceData templateData = (TemplatePersistenceData) element;
				if (!templateData.isEnabled())
					return fgcDisabled;
			}
			return fgcEnabled;
		}

	}

	/**
	 * Content provider for templates. Provides all the templates defined for
	 * this editor and optionally the disabled ones.
	 */
	private class TemplatesContentProvider implements ITreeContentProvider {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
		 */
		public Object[] getChildren(Object parentElement) {
			if (parentElement instanceof TemplatePersistenceData)
				return new Object[0];
			else if (parentElement instanceof TemplateContextType) {
				TemplateContextType contextType = (TemplateContextType) parentElement;
				return getTemplates(contextType.getId());
			}
			return null;
		}

		/**
		 * Get the templates for a given contextId. if ShowDisabled is selected
		 * the disabled templates are also included.
		 * 
		 * @param contextId
		 * @return the templates
		 */
		private TemplatePersistenceData[] getTemplates(String contextId) {
			List templateList = new ArrayList();
			TemplatePersistenceData[] datas = fTemplateStore.getTemplateData(false);
			for (int i = 0; i < datas.length; i++) {
				if ((fShowDisabled || datas[i].isEnabled())
						&& datas[i].getTemplate().getContextTypeId().equals(contextId))
					templateList.add(datas[i]);
			}
			return (TemplatePersistenceData[]) templateList
					.toArray(new TemplatePersistenceData[templateList.size()]);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
		 */
		public Object getParent(Object element) {
			if (element instanceof TemplatePersistenceData) {
				TemplatePersistenceData templateData = (TemplatePersistenceData) element;
				return fContextTypeRegistry.getContextType(templateData.getTemplate()
						.getContextTypeId());
			}
			return null;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
		 */
		public boolean hasChildren(Object element) {
			if (element instanceof TemplateContextType)
				return true;
			return false;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
		 */
		public Object[] getElements(Object inputElement) {
			List contextTypes = new ArrayList();

			for (Iterator iterator = fContextTypeRegistry.contextTypes(); iterator.hasNext();) {
				TemplateContextType contextType = (TemplateContextType) iterator.next();
				if (isActiveContext(contextType) || !fLinkWithEditor)
					contextTypes.add(contextType);
			}
			return contextTypes.toArray(new TemplateContextType[contextTypes.size()]);
		}

		/**
		 * Checks whether given context type is active for displaying the
		 * templates
		 * 
		 * @param contextType
		 * @return true if context is active
		 */
		private boolean isActiveContext(TemplateContextType contextType) {
			return fActiveTypes == null || fActiveTypes.contains(contextType.getId());
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
		 */
		public void dispose() {
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
		 *      java.lang.Object, java.lang.Object)
		 */
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		}
	}

	/**
	 * Show/Hide new dialog
	 */
	private static final int SHOW_DIALOG = 0;
	private static final int MAY_HIDE_DIALOG = 1;

	/** The viewer displays the pattern of selected template. */
	private SourceViewer fPatternViewer;
	/** The store for our templates. */
	private TemplateStore fTemplateStore;
	/**
	 * The template stores preference page. Used to listen to the changes and
	 * update the view. Needed when the user selects Preferences and updates the
	 * templates.
	 */
	private IPreferenceStore fTemplatePreferenceStore;
	private IPropertyChangeListener fTemplateChangeListener;
	/** The context type registry. */
	private ContextTypeRegistry fContextTypeRegistry;

	/** The control for this page book view */
	private SashForm fControl;

	/* Actions */
	private Action fInsertAction;
	private Action fAddAction;
	private Action fEditAction;
	private Action fRemoveAction;
	private Action fLinkWithEditorAction;
	private Action fExpandCollapseAction;
	private Action fPreferencePageAction;
	private Action fShowDisabledAction;
	private Action fShowNewDialogOnDropAction;

	/* Clipboard actions */
	private Action fPasteAction;
	private Action fCopyAction;

	/* Options and values saved in preference store */
	private boolean fLinkWithEditor ;
	private boolean fShowDisabled ;
	private boolean fShowNewDialogOnDrop ;
	private int fSashSize;
	private int fNameWidth;
	private int fDescriptionWidth ;
	
	/** Currently selected templates and type */
	private ArrayList fSelectedTemplateList = new ArrayList();
	private TemplateContextType fSelectedType;

	/** Current active context types for the editor */
	private List fActiveTypes;

	/* Preference stores */
	/**
	 * Preference store to store the dialog setting for this page
	 */
	private IPreferenceStore fPreferenceStore;

	/* Controls */
	private Tree fTemplatesTree;
	private TreeViewer fTreeViewer;
	private Menu fContextMenu;

	/**
	 * Creates a new template view page.
	 * 
	 * @param templateStore
	 * @param templatePreferenceStore
	 * @param registry
	 */
	protected TemplatesPage(TemplateStore templateStore, IPreferenceStore templatePreferenceStore,
			ContextTypeRegistry registry) {
		super();
		setupPreferenceStore();
		fTemplateStore = templateStore;
		fTemplatePreferenceStore = templatePreferenceStore;
		fContextTypeRegistry = registry;
		if (fTemplatePreferenceStore != null) {
			fTemplateChangeListener = new IPropertyChangeListener() {
				public void propertyChange(PropertyChangeEvent event) {
					refresh();
				}
			};
			fTemplatePreferenceStore.addPropertyChangeListener(fTemplateChangeListener);
		}
	}

	private void setupPreferenceStore() {
		fPreferenceStore = TextEditorPlugin.getDefault().getPreferenceStore();
		fPreferenceStore.setDefault(LINK_ACTION_PREF_ID, true);
		fPreferenceStore.setDefault(SHOW_DISABLED_ACTION_PREF_ID, false);
		fPreferenceStore.setDefault(SHOW_NEW_DIALOG_ACTION_PREF_ID, true);
		fPreferenceStore.setDefault(SASH_SIZE_PREF_ID, 80);
		fLinkWithEditor = fPreferenceStore.getBoolean(LINK_ACTION_PREF_ID);
		fShowDisabled = fPreferenceStore.getBoolean(SHOW_DISABLED_ACTION_PREF_ID);
		fShowNewDialogOnDrop = fPreferenceStore.getBoolean(SHOW_NEW_DIALOG_ACTION_PREF_ID);
		fSashSize = fPreferenceStore.getInt(SASH_SIZE_PREF_ID);
	}

	/**
	 * Check whether the linked editor is modifiable
	 * 
	 * @return true if the editor is modifiable
	 */
	protected boolean isEditorModifiable() {
		return true;
	}

	/**
	 * Check whether the template is valid for the current drop position
	 * 
	 * @param template
	 * @param x
	 * @param y
	 * @return true if the template is valid
	 */
	protected boolean isValidTemplateForPosition(Template template, int x, int y) {
		return true;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.part.Page#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite ancestor) {
		setupActions();

		fControl = new SashForm(ancestor, SWT.VERTICAL);

		createTemplateTree();
		createPatternViewer(fControl);

		hookContextMenu();
		initializeDND();
		updateButtons();

		fControl.setWeights(new int[] { fSashSize, 100 - fSashSize });
	}

	/**
	 * Setup the actions
	 */
	private void setupActions() {
		createActions();
		IActionBars actionBars = getSite().getActionBars();
	
		actionBars.setGlobalActionHandler(ActionFactory.PASTE.getId(), fPasteAction);
		actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(), fCopyAction);
	
		fillToolbar(actionBars);
		fillMenu(actionBars);
	}

	/**
	 * Create actions for this view
	 */
	private void createActions() {
		fInsertAction = new Action(TextEditorTemplateMessages.TemplatesPage_insert) {
			public void run() {
				insertTemplate(getSelectedTemplate());
			}
		};
		fInsertAction.setToolTipText(TextEditorTemplateMessages.TemplatesPage_insert_tooltip);
	
		fAddAction = new Action(TextEditorTemplateMessages.TemplatesPage_new) {
			public void run() {
				addTemplate();
			}
		};
		fAddAction.setImageDescriptor(TemplatesViewImages
				.getImageDescriptor(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_NEW));
		fAddAction.setToolTipText(TextEditorTemplateMessages.TemplatesPage_new_tooltip);
	
		fEditAction = new Action(TextEditorTemplateMessages.TemplatesPage_edit) {
			public void run() {
				editTemplate();
			}
		};
		fEditAction.setImageDescriptor(TemplatesViewImages
				.getImageDescriptor(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_EDIT));
		fEditAction.setDisabledImageDescriptor(TemplatesViewImages
				.getImageDescriptor(ITemplatesViewImageConstants.IMG_DLCL_TEMPLATE_EDIT));
		fEditAction.setToolTipText(TextEditorTemplateMessages.TemplatesPage_edit_tooltip);
	
		fRemoveAction = new Action(TextEditorTemplateMessages.TemplatesPage_remove) {
			public void run() {
				removeTemplate();
			}
		};
		fRemoveAction.setImageDescriptor(TemplatesViewImages
				.getImageDescriptor(ITemplatesViewImageConstants.IMG_DLCL_TEMPLATE_DELETE));
		fRemoveAction.setImageDescriptor(TemplatesViewImages
				.getImageDescriptor(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_DELETE));
		fRemoveAction.setToolTipText(TextEditorTemplateMessages.TemplatesPage_remove_tooltip);
	
		fLinkWithEditorAction = new Action(TextEditorTemplateMessages.TemplatesPage_link_to_editor,
				IAction.AS_CHECK_BOX) {
			public void run() {
				fLinkWithEditor = fLinkWithEditorAction.isChecked();
				refresh();
			}
		};
		fLinkWithEditorAction.setImageDescriptor(TemplatesViewImages
				.getImageDescriptor(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_LINK));
		fLinkWithEditorAction.setChecked(fPreferenceStore.getBoolean(LINK_ACTION_PREF_ID));
		fLinkWithEditorAction.setToolTipText(TextEditorTemplateMessages.TemplatesPage_link_to_editor_tooltip);
		fExpandCollapseAction = new Action(TextEditorTemplateMessages.TemplatesPage_collapse_expand) {
			public void run() {
				Object[] vee = fTreeViewer.getVisibleExpandedElements();
				boolean collapse = vee.length != 0;
				if (collapse)
					fTreeViewer.collapseAll();
				else
					fTreeViewer.expandAll();
			}
		};
		fExpandCollapseAction.setImageDescriptor(TemplatesViewImages
				.getImageDescriptor(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_COLLAPSE_EXPAND));
		fExpandCollapseAction
				.setToolTipText(TextEditorTemplateMessages.TemplatesPage_collapse_expand_tooltip);
	
		if (getPreferencePageId() != null) {
			fPreferencePageAction = new Action(
					TextEditorTemplateMessages.TemplatesPage_preference_page) {
				public void run() {
					showPreferencePage();
				}
			};
			fPreferencePageAction
					.setToolTipText(TextEditorTemplateMessages.TemplatesPage_preference_page_tooltip);
		}
	
		fShowDisabledAction = new Action(TextEditorTemplateMessages.TemplatesPage_show_disabled,
				IAction.AS_CHECK_BOX) {
			public void run() {
				fShowDisabled = fShowDisabledAction.isChecked();
				refresh();
			}
		};
		fShowDisabledAction.setChecked(fPreferenceStore.getBoolean(SHOW_DISABLED_ACTION_PREF_ID));
		fShowDisabledAction
				.setToolTipText(TextEditorTemplateMessages.TemplatesPage_show_disabled_tooltip);
	
		fShowNewDialogOnDropAction = new Action(
				TextEditorTemplateMessages.TemplatesPage_show_new_dialog, IAction.AS_CHECK_BOX) {
			public void run() {
				fShowNewDialogOnDrop = fShowNewDialogOnDropAction.isChecked();
			}
		};
		fShowNewDialogOnDropAction.setChecked(fPreferenceStore
				.getBoolean(SHOW_NEW_DIALOG_ACTION_PREF_ID));
		fShowNewDialogOnDropAction
				.setToolTipText(TextEditorTemplateMessages.TemplatesPage_show_new_dialog_tooltip);
	
		fPasteAction = new Action() {
			public void run() {
				Clipboard clipBoard = new Clipboard(getShell().getDisplay());
				final Template template = getTemplateFromCB(clipBoard);
				if (template == null)
					return;
				getShell().getDisplay().asyncExec(new Runnable() {
					public void run() {
						addTemplate(template, MAY_HIDE_DIALOG);
					}
				});
			}
	
			private Template getTemplateFromCB(Clipboard clipBoard) {
				String text = (String) clipBoard.getContents(TextTransfer.getInstance());
				if (text == null)
					return getTemplateFromTemplate(clipBoard);
				return new Template(TextEditorTemplateMessages.TemplatesPage_snippet,
						TextEditorTemplateMessages.TemplatesPage_paste_description,
						getContextTypeId(), text.replaceAll("\\$", "\\$\\$"), true); //$NON-NLS-1$ //$NON-NLS-2$
			}
	
			private Template getTemplateFromTemplate(Clipboard clipBoard) {
				Object contents = clipBoard.getContents(TemplateTransfer.getInstance());
				if (contents == null)
					return null;
				Template t = ((Template[]) contents)[0];
				return new Template(t.getName(), t.getDescription(), getContextTypeId(), t
						.getPattern(), true);
			}
		};
	
		fCopyAction = new Action() {
			public void run() {
				if (!isSingleTemplateSelected())
					return;
				Template[] templates = new Template[] { getSelectedTemplate() };
				Clipboard clipBoard = new Clipboard(getShell().getDisplay());
				clipBoard.setContents(new Object[] { templates }, new Transfer[] { TemplateTransfer
						.getInstance() });
			}
		};
	}

	/**
	 * Fill the menu items
	 * 
	 * @param actionBars
	 */
	private void fillMenu(IActionBars actionBars) {
		IMenuManager menuManager = actionBars.getMenuManager();
	
		if (fPreferencePageAction != null) {
			menuManager.add(fPreferencePageAction);
			menuManager.add(new Separator());
		}
		menuManager.add(fShowDisabledAction);
		menuManager.add(fShowNewDialogOnDropAction);
	
		menuManager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
	}

	/**
	 * Fill items into the toolbar
	 * 
	 * @param actionBars
	 */
	private void fillToolbar(IActionBars actionBars) {
		IToolBarManager toolBarManager = actionBars.getToolBarManager();
		toolBarManager.add(fAddAction);
		toolBarManager.add(fEditAction);
		toolBarManager.add(fRemoveAction);
	
		toolBarManager.add(new Separator());
	
		toolBarManager.add(fLinkWithEditorAction);
		toolBarManager.add(fExpandCollapseAction);
	}

	/**
	 * Setup the context menu for the viewer.
	 */
	private void hookContextMenu() {
		MenuManager menuMgr = new MenuManager(POPUP_MENU_ID);
		menuMgr.setRemoveAllWhenShown(true);
		menuMgr.addMenuListener(new IMenuListener() {
			public void menuAboutToShow(IMenuManager manager) {
				fillContextMenu(manager);
			}
		});
		fContextMenu = menuMgr.createContextMenu(fTreeViewer.getControl());
		fTreeViewer.getControl().setMenu(fContextMenu);
		getSite().registerContextMenu(POPUP_MENU_ID, menuMgr, fTreeViewer);
	}

	/**
	 * Fill up the context menu
	 * 
	 * @param manager
	 */
	private void fillContextMenu(IMenuManager manager) {
		manager.add(fInsertAction);
		manager.add(new Separator());
		manager.add(fAddAction);
		manager.add(fEditAction);
		manager.add(fRemoveAction);
		// Other plug-ins can contribute there actions here
		manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
	}

	/**
	 * Create the tree control to display template information
	 */
	private void createTemplateTree() {
		Composite treeComposite = new Composite(fControl, SWT.NONE);
		GridData data = new GridData(GridData.FILL_BOTH);
		treeComposite.setLayoutData(data);

		TreeColumnLayout columnLayout = new TreeColumnLayout();
		treeComposite.setLayout(columnLayout);
		fTemplatesTree = new Tree(treeComposite, SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI
				| SWT.FULL_SELECTION);
		fTemplatesTree.setHeaderVisible(true);
		fTemplatesTree.setLinesVisible(true);

		GC gc = new GC(getShell());
		gc.setFont(JFaceResources.getDialogFont());

		TreeColumn columnName = new TreeColumn(fTemplatesTree, SWT.NONE);
		columnName.setText(TextEditorTemplateMessages.TemplatesPage_column_name);
		int minWidth = fPreferenceStore.getInt(COLUMN_NAME_WIDTH_PREF_ID);
		if (minWidth == 0)
			minWidth = gc.stringExtent(TextEditorTemplateMessages.TemplatesPage_column_name).x + 10;
		columnLayout.setColumnData(columnName, new ColumnPixelData(minWidth, false));
		columnName.addControlListener(new ControlListener() {
			public void controlMoved(ControlEvent e) {
			}

			public void controlResized(ControlEvent e) {
				fNameWidth = ((TreeColumn)e.getSource()).getWidth();
			}
		});

		TreeColumn columnDescription = new TreeColumn(fTemplatesTree, SWT.NONE);
		columnDescription.setText(TextEditorTemplateMessages.TemplatesPage_column_description);
		minWidth = fPreferenceStore.getInt(COLUMN_DESCRIPTION_WIDTH_PREF_ID);
		if (minWidth == 0)
			minWidth = gc.stringExtent(TextEditorTemplateMessages.TemplatesPage_column_description).x + 10;
		columnLayout.setColumnData(columnDescription, new ColumnPixelData(minWidth, false));
		columnDescription.addControlListener(new ControlListener() {
			public void controlMoved(ControlEvent e) {
			}

			public void controlResized(ControlEvent e) {
				fDescriptionWidth = ((TreeColumn)e.getSource()).getWidth();
			}
		});


		gc.dispose();

		createTreeViewer();
	}

	/**
	 * Create the viewer for the tree control and configure it.
	 */
	private void createTreeViewer() {
		fTreeViewer = new TreeViewer(fTemplatesTree);
		fTreeViewer.setLabelProvider(new TemplateLabelProvider());
		fTreeViewer.setContentProvider(new TemplatesContentProvider());

		fTreeViewer.setComparator(new TemplateViewerComparator());
		fTreeViewer.setInput(fTemplateStore);
		fTreeViewer.addDoubleClickListener(new IDoubleClickListener() {
			public void doubleClick(DoubleClickEvent e) {
				updateSelectedItems();
				insertTemplate(getSelectedTemplate());
			}
		});

		fTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent e) {
				updateSelectedItems();
				updateButtons();
			}
		});
		fTreeViewer.expandAll();
	}

	/**
	 * Create a viewer to display the pattern
	 * 
	 * @param parent
	 */
	private void createPatternViewer(Composite parent) {
		ViewForm viewForm = new ViewForm(parent, SWT.NONE);
		viewForm.setBorderVisible(false);
		CLabel previewLabel = new CLabel(viewForm, SWT.NONE);
		previewLabel.setText(TextEditorTemplateMessages.TemplatesPage_preview);
		previewLabel.setImage(TemplatesViewImages
				.getImage(ITemplatesViewImageConstants.IMG_OBJ_PREVIEW));
		viewForm.setTopLeft(previewLabel);
	
		fPatternViewer = createViewer(viewForm);
		fPatternViewer.setEditable(false);
		viewForm.setContent(fPatternViewer.getControl());
		viewForm.addControlListener(new ControlListener() {
			public void controlMoved(ControlEvent e) {
			}
	
			public void controlResized(ControlEvent e) {
				int[] weights = fControl.getWeights();
				fSashSize = (int) (weights[0] * 100.0 / (weights[0] + weights[1]));
			}
		});
	}

	/**
	 * Update the selected template list, type and pattern viewer
	 */
	private void updateSelectedItems() {
		IStructuredSelection selection = (IStructuredSelection) fTreeViewer.getSelection();

		fSelectedTemplateList.clear();
		fSelectedType = null;

		if (selection.size() == 1) {
			Object item = selection.getFirstElement();
			if (item instanceof TemplateContextType)
				fSelectedType = (TemplateContextType) item;
			else
				fSelectedTemplateList.add(item);
		} else if (selection.size() > 1) {
			for (Iterator iterator = selection.iterator(); iterator.hasNext();) {
				Object item = iterator.next();
				if (item instanceof TemplateContextType) {
					fSelectedTemplateList.clear();
					break;
				}
				fSelectedTemplateList.add(item);
			}
		}
		if (!fSelectedTemplateList.isEmpty()) {
			String contextTypeId = ((TemplatePersistenceData) fSelectedTemplateList.get(0))
					.getTemplate().getContextTypeId();
			fSelectedType = fContextTypeRegistry.getContextType(contextTypeId);
			for (Iterator iterator = fSelectedTemplateList.iterator(); iterator.hasNext();) {
				TemplatePersistenceData template = (TemplatePersistenceData) iterator.next();
				if (!contextTypeId.equals(template.getTemplate().getContextTypeId())) {
					fSelectedType = null;
					break;
				}
			}
		}
		if (isSingleTemplateSelected()) {
			updateViewerInput(getSelectedTemplate());
		} else
			fPatternViewer.getDocument().set(""); //$NON-NLS-1$
	}

	/**
	 * Checks whether only one template is selected in the tree
	 * 
	 * @return true if only single template is selected
	 */
	private boolean isSingleTemplateSelected() {
		return fSelectedTemplateList.size() == 1;
	}

	/**
	 * Get the selected template. Note: should always precede with a check for
	 * isSingleTemplateSelected
	 * 
	 * @return the template (Not the data)
	 */
	private Template getSelectedTemplate() {
		return ((TemplatePersistenceData) fSelectedTemplateList.get(0)).getTemplate();
	}

	/**
	 * Show the preference templates preference page
	 */
	private void showPreferencePage() {
		PreferencesUtil.createPreferenceDialogOn(getShell(), getPreferencePageId(), null, null)
				.open();
	}

	/**
	 * Get the preference page ID for the templates for the given editor.
	 * Subclasses should override.
	 * 
	 * @return id of the preference page
	 */
	protected String getPreferencePageId() {
		return null;
	}

	/**
	 * Get the shell
	 * 
	 * @return the shell for this view site
	 */
	protected Shell getShell() {
		return getSite().getShell();
	}

	/**
	 * Creates, configures and returns a source viewer to present the template
	 * pattern on the preference page. Clients may override to provide a custom
	 * source viewer featuring e.g. syntax coloring.
	 * 
	 * @param parent
	 *            the parent control
	 * @return a configured source viewer
	 */
	protected SourceViewer createViewer(Composite parent) {
		SourceViewer viewer = new SourceViewer(parent, null, null, false, SWT.BORDER | SWT.V_SCROLL
				| SWT.H_SCROLL);
		SourceViewerConfiguration configuration = new SourceViewerConfiguration();
		viewer.configure(configuration);
		IDocument document = new Document();
		viewer.setDocument(document);
		return viewer;
	}

	/**
	 * Updates the pattern viewer.
	 * 
	 * @param template
	 */
	protected void updateViewerInput(Template template) {
		if (template != null)
			fPatternViewer.getDocument().set(template.getPattern());
		else
			fPatternViewer.getDocument().set(""); //$NON-NLS-1$
	}

	/**
	 * Updates the buttons.
	 */
	private void updateButtons() {
		fCopyAction.setEnabled(isSingleTemplateSelected());
		fInsertAction.setEnabled(isSingleTemplateSelected());
		fEditAction.setEnabled(isSingleTemplateSelected());
		fRemoveAction.setEnabled(fSelectedTemplateList.size() != 0);
	}

	/**
	 * Add a template
	 */
	private void addTemplate() {
		String id = getContextTypeId();
		if (id != null) {
			Template template = new Template("", "", id, "", true); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			addTemplate(template, SHOW_DIALOG);
		}
	}

	/**
	 * Get the selected or the first context type from the registry.
	 * 
	 * @return id of the context type
	 */
	private String getContextTypeId() {
		if (fSelectedType != null)
			return fSelectedType.getId();
		Iterator it = fContextTypeRegistry.contextTypes();
		if (it.hasNext())
			return ((TemplateContextType) it.next()).getId();
		return null;
	}

	/**
	 * Add a template
	 * 
	 * Setting ui to SHOW_DIALOG will force a New dialog. Setting it to
	 * MAY_HIDE_DIALOG will respect the show new dialog on drop option.
	 * 
	 * @param template
	 * @param ui
	 */
	private void addTemplate(Template template, int ui) {
		Template newTemplate;
		if (ui == SHOW_DIALOG || fShowNewDialogOnDrop)
			newTemplate = editTemplate(template, false, true);
		else
			newTemplate = template;
		if (newTemplate != null) {
			TemplatePersistenceData data = new TemplatePersistenceData(newTemplate, true);
			fTemplateStore.add(data);
			saveTemplateStore();
			fSelectedTemplateList.clear();
			fSelectedTemplateList.add(data);
			changeSelection();
		}
	}

	/**
	 * Save the template store
	 */
	private void saveTemplateStore() {
		try {
			fTemplateStore.save();
		} catch (IOException e) {
			e.printStackTrace();
			MessageDialog.openError(getShell(),
					TextEditorTemplateMessages.TemplatesPage_save_error_message, e.getMessage());
		}
	}

	/**
	 * Change selection in the viewer. oldData will contain the earlier selected
	 * template and fCurrentTemplateData will hold the current selection. Either
	 * can be null.
	 * 
	 */
	private void changeSelection() {
		fTreeViewer.refresh();
		if (isSingleTemplateSelected())
			fTreeViewer.setSelection(new StructuredSelection(fSelectedTemplateList.get(0)), true);
		else
			fTreeViewer.setSelection(new StructuredSelection());
		updateSelectedItems();
	}

	/**
	 * Creates the edit dialog. Subclasses may override this method to provide a
	 * custom dialog.
	 * 
	 * @param template
	 *            the template being edited
	 * @param edit
	 *            whether the dialog should be editable
	 * @param isNameModifiable
	 *            whether the template name may be modified
	 * @return the created or modified template, or <code>null</code> if the
	 *         edition failed
	 * @since 3.1
	 */
	protected Template editTemplate(Template template, boolean edit, boolean isNameModifiable) {
		EditTemplateDialog dialog = new EditTemplateDialog(getShell(), template, edit,
				isNameModifiable, fContextTypeRegistry);
		if (dialog.open() == Window.OK) {
			return dialog.getTemplate();
		}
		return null;
	}

	/**
	 * Edit the current template
	 */
	private void editTemplate() {
		Template oldTemplate = getSelectedTemplate();
		Template newTemplate = editTemplate(new Template(oldTemplate), true, true);
		if (newTemplate != null) {
			if (!newTemplate.getName().equals(oldTemplate.getName())
					&& MessageDialog.openQuestion(getShell(),
							TextEditorTemplateMessages.TemplatesPage_question_create_new_title,
							TextEditorTemplateMessages.TemplatesPage_question_create_new_message)) {
				fSelectedTemplateList.clear();
				TemplatePersistenceData templateData = new TemplatePersistenceData(newTemplate,
						true);
				fSelectedTemplateList.add(templateData);
				fTemplateStore.add(templateData);
			} else {
				((TemplatePersistenceData) fSelectedTemplateList.get(0)).setTemplate(newTemplate);
			}
			changeSelection();
		}
		saveTemplateStore();
	}

	/**
	 * Remove the currently selected templates
	 */
	private void removeTemplate() {
		if (!MessageDialog.openQuestion(getShell(),
				TextEditorTemplateMessages.TemplatesPage_remove_title,
				TextEditorTemplateMessages.TemplatesPage_remove_message))
			return;
		for (Iterator iterator = fSelectedTemplateList.iterator(); iterator.hasNext();) {
			TemplatePersistenceData data = (TemplatePersistenceData) iterator.next();
			fTemplateStore.delete(data);
		}
		saveTemplateStore();
		fSelectedTemplateList.clear();
		changeSelection();
	}

	/**
	 * Get the pattern viewer. Subclass can override
	 * 
	 * @return the viewer
	 */
	protected SourceViewer getViewer() {
		return fPatternViewer;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.part.Page#getControl()
	 */
	public Control getControl() {
		return fControl;
	}

	/**
	 * Subclasses should override and facilitate inserting the template code
	 * into the active editor.
	 * 
	 * @param template
	 */
	public void insertTemplate(Template template) {
	}

	/**
	 * The caret position in the editor has moved into a new context type. It is
	 * the subclasses responsibility to see that this is called only when needed
	 * by keeping track of editor contents (eg. partitions).
	 * 
	 * @param ids
	 */
	protected void contextTypeChanged(String[] ids) {
		fActiveTypes = Arrays.asList(ids);
		if (fLinkWithEditorAction != null && fLinkWithEditor)
			refresh();
	}

	/**
	 * Initialize drag and drop the the template items
	 */
	private void initializeDND() {
		DragSourceAdapter dragListener = new DragSourceAdapter() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.dnd.DragSourceAdapter#dragSetData(org.eclipse.swt.dnd.DragSourceEvent)
			 */
			public void dragSetData(DragSourceEvent event) {
				if (isSingleTemplateSelected()
						&& TemplateTransfer.getInstance().isSupportedType(event.dataType)) {
					event.data = new Template[] { getSelectedTemplate() };
				}
			}
		};
		fTreeViewer.addDragSupport(DND.DROP_COPY,
				new Transfer[] { TemplateTransfer.getInstance() }, dragListener);
		DropTargetAdapter dropListener = new DropTargetAdapter() {
			TextTransfer textTransfer = TextTransfer.getInstance();
			TemplateTransfer templateTransfer = TemplateTransfer.getInstance();

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.dnd.DropTargetAdapter#dragEnter(org.eclipse.swt.dnd.DropTargetEvent)
			 */
			public void dragEnter(DropTargetEvent event) {
				if (event.detail == DND.DROP_DEFAULT)
					event.detail = DND.DROP_COPY;
			}

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.dnd.DropTargetAdapter#dragOperationChanged(org.eclipse.swt.dnd.DropTargetEvent)
			 */
			public void dragOperationChanged(DropTargetEvent event) {
				if (event.detail == DND.DROP_DEFAULT)
					event.detail = DND.DROP_COPY;
			}

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.dnd.DropTargetAdapter#dragOver(org.eclipse.swt.dnd.DropTargetEvent)
			 */
			public void dragOver(DropTargetEvent event) {
				event.detail = DND.DROP_NONE;
				if (event.item == null)
					return;
				int index = 0;
				while (index < event.dataTypes.length) {
					if (textTransfer.isSupportedType(event.dataTypes[index]))
						break;
					if (templateTransfer.isSupportedType(event.dataTypes[index]))
						break;
					index++;
				}
				if (index < event.dataTypes.length) {
					event.currentDataType = event.dataTypes[index];
					event.detail = DND.DROP_COPY;
					return;
				}
			}

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.swt.dnd.DropTargetAdapter#drop(org.eclipse.swt.dnd.DropTargetEvent)
			 */
			public void drop(DropTargetEvent event) {
				if (event.item == null)
					return;
				Object object = ((TreeItem) event.item).getData();
				String contextId;
				if (object instanceof TemplateContextType)
					contextId = ((TemplateContextType) object).getId();
				else
					contextId = ((TemplatePersistenceData) object).getTemplate().getContextTypeId();
				if (textTransfer.isSupportedType(event.currentDataType)) {
					String text = (String) event.data;
					final Template template = new Template(
							TextEditorTemplateMessages.TemplatesPage_snippet,
							TextEditorTemplateMessages.TemplatesPage_paste_description, contextId,
							text.replaceAll("\\$", "\\$\\$"), true); //$NON-NLS-1$//$NON-NLS-2$
					getShell().getDisplay().asyncExec(new Runnable() {
						public void run() {
							addTemplate(template, MAY_HIDE_DIALOG);
						}
					});
				} else if (templateTransfer.isSupportedType(event.currentDataType)) {
					Template[] templates = (Template[]) event.data;
					Template t = templates[0];
					final Template template = new Template(t.getName(), t.getDescription(),
							contextId, t.getPattern(), true);
					getShell().getDisplay().asyncExec(new Runnable() {
						public void run() {
							addTemplate(template, MAY_HIDE_DIALOG);
						}
					});
				}
			}

		};
		fTreeViewer.addDropSupport(DND.DROP_COPY, new Transfer[] { TemplateTransfer.getInstance(),
				TextTransfer.getInstance() }, dropListener);
	}

	/**
	 * Setup the editor site as a drop target. Should be invoked by the
	 * subclasses for the D&D to work with the editor.
	 * 
	 * @param site
	 * @param viewer
	 */
	protected void setupEditorDropTarget(IWorkbenchPartSite site, Control viewer) {
		IDragAndDropService dndService = (IDragAndDropService) site
				.getService(IDragAndDropService.class);
		EditorDropTarget editorDropTarget = new EditorDropTarget();
		dndService.addMergedDropTarget(viewer, DND.DROP_COPY, new Transfer[] { TemplateTransfer
				.getInstance() }, editorDropTarget);
	}

	/**
	 * Refresh the template tree contents
	 */
	private void refresh() {
		fTreeViewer.refresh();
		fTreeViewer.expandAll();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.part.Page#setFocus()
	 */
	public void setFocus() {
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.part.Page#dispose()
	 */
	public void dispose() {
		if (fContextMenu != null && !fContextMenu.isDisposed())
			fContextMenu.dispose();
		fTemplatePreferenceStore.removePropertyChangeListener(fTemplateChangeListener);
		savePreferences();
		super.dispose();
	}

	/**
	 * Save the preferences
	 */
	private void savePreferences() {
		fPreferenceStore.setValue(SASH_SIZE_PREF_ID, fSashSize);
		fPreferenceStore.setValue(LINK_ACTION_PREF_ID, fLinkWithEditor);
		fPreferenceStore.setValue(SHOW_DISABLED_ACTION_PREF_ID, fShowDisabled);
		fPreferenceStore.setValue(SHOW_NEW_DIALOG_ACTION_PREF_ID, fShowNewDialogOnDrop);
		fPreferenceStore.setValue(COLUMN_NAME_WIDTH_PREF_ID, fNameWidth);
		fPreferenceStore.setValue(COLUMN_DESCRIPTION_WIDTH_PREF_ID, fDescriptionWidth);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.texteditor.templates;

import java.net.URL;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.internal.texteditor.TextEditorPlugin;
import org.osgi.framework.Bundle;

/**
 * The images provided by the texteditor plugin
 * @since 3.4
 */
public class TemplatesViewImages {

	/**
	 * The image registry containing <code>Image</code>s.
	 */
	private static ImageRegistry imageRegistry;

	private static String ICONS_PATH = "$nl$/icons/full/"; //$NON-NLS-1$

	// Use IPath and toOSString to build the names to ensure they have the
	// slashes correct
	private final static String ELCL = ICONS_PATH + "elcl16/"; //$NON-NLS-1$
	private final static String DLCL = ICONS_PATH + "dlcl16/"; //$NON-NLS-1$
	private final static String OBJ = ICONS_PATH + "obj16/"; //$NON-NLS-1$

	/**
	 * Declare all images
	 */
	private static void declareImages() {
		// Ant Editor images
		declareRegistryImage(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_NEW, ELCL
				+ "new_template.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_DELETE, ELCL
				+ "delete_template.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_DLCL_TEMPLATE_DELETE, DLCL
				+ "delete_template.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_EDIT, ELCL
				+ "edit_template.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_DLCL_TEMPLATE_EDIT, DLCL
				+ "edit_template.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_LINK, ELCL
				+ "link_to_editor.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_ELCL_TEMPLATE_COLLAPSE_EXPAND, ELCL
				+ "collapse_expand_all.gif"); //$NON-NLS-1$

		declareRegistryImage(ITemplatesViewImageConstants.IMG_OBJ_PREVIEW, OBJ + "preview.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_OBJ_CONTEXT, OBJ + "context.gif"); //$NON-NLS-1$
		declareRegistryImage(ITemplatesViewImageConstants.IMG_OBJ_TEMPLATE, OBJ + "template.gif"); //$NON-NLS-1$
	}

	/**
	 * Declare an Image in the registry table.
	 * 
	 * @param key
	 *            The key to use when registering the image
	 * @param path
	 *            The path where the image can be found. This path is relative
	 *            to where this plugin class is found (i.e. typically the
	 *            packages directory)
	 */
	private final static void declareRegistryImage(String key, String path) {
		ImageDescriptor desc = ImageDescriptor.getMissingImageDescriptor();
		Bundle bundle = Platform.getBundle(TextEditorPlugin.PLUGIN_ID);
		URL url = null;
		if (bundle != null) {
			url = FileLocator.find(bundle, new Path(path), null);
			desc = ImageDescriptor.createFromURL(url);
		}
		imageRegistry.put(key, desc);
	}

	/**
	 * Returns the ImageRegistry.
	 * 
	 * @return image registry
	 */
	public static ImageRegistry getImageRegistry() {
		if (imageRegistry == null) {
			initializeImageRegistry();
		}
		return imageRegistry;
	}

	/**
	 * Initialize the image registry by declaring all of the required graphics.
	 * This involves creating JFace image descriptors describing how to
	 * create/find the image should it be needed. The image is not actually
	 * allocated until requested.
	 * 
	 * Prefix conventions Wizard Banners WIZBAN_ Preference Banners PREF_BAN_
	 * Property Page Banners PROPBAN_ Color toolbar CTOOL_ Enable toolbar ETOOL_
	 * Disable toolbar DTOOL_ Local enabled toolbar ELCL_ Local Disable toolbar
	 * DLCL_ Object large OBJL_ Object small OBJS_ View VIEW_ Product images
	 * PROD_ Misc images MISC_
	 * 
	 * Where are the images? The images (typically gifs) are found in the same
	 * location as this plugin class. This may mean the same package directory
	 * as the package holding this class. The images are declared using
	 * this.getClass() to ensure they are looked up via this plugin class.
	 * 
	 * @return the image registry
	 * @see org.eclipse.jface.resource.ImageRegistry
	 */
	public static ImageRegistry initializeImageRegistry() {
		imageRegistry = new ImageRegistry(getStandardDisplay());
		declareImages();
		return imageRegistry;
	}

	/**
	 * 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 the display
	 */
	public static Display getStandardDisplay() {
		Display display = Display.getCurrent();
		if (display == null) {
			display = Display.getDefault();
		}
		return display;
	}

	/**
	 * Returns the <code>Image<code> identified by the given key,
	 * or <code>null</code> if it does not exist.
	 * @param key 
	 * @return the image
	 */
	public static Image getImage(String key) {
		return getImageRegistry().get(key);
	}

	/**
	 * Returns the <code>ImageDescriptor<code> identified by the given key,
	 * or <code>null</code> if it does not exist.
	 * @param key 
	 * @return the image descriptor
	 */
	public static ImageDescriptor getImageDescriptor(String key) {
		return getImageRegistry().getDescriptor(key);
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.texteditor.templates;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;

import org.eclipse.jface.text.templates.Template;
import org.eclipse.swt.dnd.ByteArrayTransfer;
import org.eclipse.swt.dnd.TransferData;

/**
 * Transfer type used for clip board and DnD operations for template objects
 * 
 * @see TemplatesPage
 *
 * @since 3.4
 */
public class TemplateTransfer extends ByteArrayTransfer {

	private static TemplateTransfer instance;

	private static final String LOCAL_NAME = TemplateTransfer.class.getName()
			+ System.currentTimeMillis();
	private static final int LOCAL_TYPE = registerType(LOCAL_NAME);

	private static String[] names = null;
	private static int types[] = null;

	/**
	 * @return the registered Transfer instance
	 */
	public static TemplateTransfer getInstance() {
		if (instance == null) {
			instance = new TemplateTransfer();
			types = new int[] { LOCAL_TYPE };
			names = new String[] { LOCAL_NAME };
		}
		return instance;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.dnd.Transfer#getTypeIds()
	 */
	protected int[] getTypeIds() {
		return types;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.dnd.Transfer#getTypeNames()
	 */
	protected String[] getTypeNames() {
		return names;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.dnd.ByteArrayTransfer#javaToNative(java.lang.Object,
	 *      org.eclipse.swt.dnd.TransferData)
	 */
	protected void javaToNative(Object object, TransferData transferData) {
		if (object == null || !(object instanceof Template[])
				|| !isSupportedType(transferData))
			return;
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		DataOutputStream dataOut = new DataOutputStream(out);
		Template[] templates = (Template[]) object;
		for (int i = 0; i < templates.length; i++) {
			writeTemplate(dataOut, templates[i]);
		}
		byte[] byteArray = out.toByteArray();
		try {
			dataOut.close();
		} catch (IOException e) {
		}
		super.javaToNative(byteArray, transferData);
	}

	/**
	 * Write a template to the output stream
	 * 
	 * @param dataOut
	 * @param template
	 */
	private void writeTemplate(DataOutputStream dataOut, Template template) {
		try {
			writeString(dataOut, template.getName());
			writeString(dataOut, template.getDescription());
			writeString(dataOut, template.getContextTypeId());
			writeString(dataOut, template.getPattern());
			dataOut.writeBoolean(template.isAutoInsertable());
		} catch (IOException e) {
		}
	}

	/**
	 * Write a string to the output stream
	 * 
	 * @param dataOut
	 * @param name
	 * @throws IOException
	 */
	private void writeString(DataOutputStream dataOut, String name)
			throws IOException {
		byte[] bytes = name.getBytes();
		dataOut.writeInt(bytes.length);
		dataOut.write(bytes);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.dnd.ByteArrayTransfer#nativeToJava(org.eclipse.swt.dnd.TransferData)
	 */
	protected Object nativeToJava(TransferData transferData) {
		byte[] bytes = (byte[]) super.nativeToJava(transferData);
		if (bytes == null)
			return null;
		ArrayList listTemplates = new ArrayList();
		ByteArrayInputStream in = new ByteArrayInputStream(bytes);
		DataInputStream dataIn = new DataInputStream(in);
		try {
			while (dataIn.available() > 0) {
				Template template = readTempate(dataIn);
				if (template == null)
					break;
				listTemplates.add(template);
			}
		} catch (IOException e) {
		} finally {
			try {
				dataIn.close();
			} catch (IOException e) {
			}
		}
		return listTemplates.toArray(new Template[listTemplates.size()]);
	}

	/**
	 * Read a template from the data input stream.
	 * 
	 * @param dataIn
	 * @return the template
	 * @throws IOException
	 */
	private Template readTempate(DataInputStream dataIn) throws IOException {
		return new Template(readString(dataIn), readString(dataIn),
				readString(dataIn), readString(dataIn), dataIn.readBoolean());
	}

	/**
	 * Read a string from the data input stream
	 * 
	 * @param dataIn
	 * @return the string
	 * @throws IOException
	 */
	private String readString(DataInputStream dataIn) throws IOException {
		byte[] bytes = new byte[dataIn.readInt()];
		dataIn.read(bytes);
		return new String(bytes);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2007 Dakshinamurthy Karra 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:
 *     Dakshinamurthy Karra - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.texteditor.templates;

import org.eclipse.ui.internal.texteditor.TextEditorPlugin;

/**
 * Image constants for the template page
 * 
 * @author kd
 * 
 * @since 3.4
 */
public interface ITemplatesViewImageConstants {
	public static final String PREFIX_ELCL = TextEditorPlugin.PLUGIN_ID + ".elcl."; //$NON-NLS-1$
	public static final String PREFIX_DLCL = TextEditorPlugin.PLUGIN_ID + ".dlcl."; //$NON-NLS-1$
	public static final String PREFIX_OBJ  = TextEditorPlugin.PLUGIN_ID + ".obj."; //$NON-NLS-1$
	
	public final static String IMG_ELCL_TEMPLATE_NEW = PREFIX_ELCL + "new_template.gif"; //$NON-NLS-1$
	public static final String IMG_ELCL_TEMPLATE_DELETE = PREFIX_ELCL + "delete_template.gif"; //$NON-NLS-1$
	public final static String IMG_ELCL_TEMPLATE_EDIT = PREFIX_ELCL + "edit_template.gif"; //$NON-NLS-1$
	public static final String IMG_ELCL_TEMPLATE_LINK = PREFIX_ELCL + "link_to_editor.gif"; //$NON-NLS-1$
	public static final String IMG_ELCL_TEMPLATE_COLLAPSE_EXPAND = PREFIX_ELCL + "collapse_expand_all.gif"; //$NON-NLS-1$
	public static final String IMG_DLCL_TEMPLATE_DELETE = PREFIX_DLCL + "delete_template.gif"; //$NON-NLS-1$
	public final static String IMG_DLCL_TEMPLATE_EDIT = PREFIX_DLCL + "edit_template.gif"; //$NON-NLS-1$
	
	public final static String IMG_OBJ_PREVIEW = PREFIX_OBJ + "preview.gif"; //$NON-NLS-1$
	public static final String IMG_OBJ_CONTEXT = PREFIX_OBJ + "context.gif"; //$NON-NLS-1$
	public static final String IMG_OBJ_TEMPLATE = PREFIX_OBJ + "template.gif"; //$NON-NLS-1$
}

Lines 92-97 Link Here

(-)Eclipse UI/org/eclipse/ui/IPageLayout.java (+5 lines)
92	public static String ID_OUTLINE = "org.eclipse.ui.views.ContentOutline"; //$NON-NLS-1$	92	public static String ID_OUTLINE = "org.eclipse.ui.views.ContentOutline"; //$NON-NLS-1$
93		93
94	/**	94	/**
		95	* The view id for the workbench's Templates standard component.
		96	*/
		97	public static String ID_TEMPLATES = "org.eclipse.ui.views.Templates"; //$NON-NLS-1$
		98
		99	/**
95	* The view id for the workbench's Bookmark Navigator standard component.	100	* The view id for the workbench's Bookmark Navigator standard component.
96	*/	101	*/
97	public static String ID_BOOKMARKS = "org.eclipse.ui.views.BookmarkView"; //$NON-NLS-1$	102	public static String ID_BOOKMARKS = "org.eclipse.ui.views.BookmarkView"; //$NON-NLS-1$

Lines 8-13 Link Here

(-)Ant Editor/org/eclipse/ant/internal/ui/editor/AntEditorMessages.properties (+6 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	# John-Mason P. Shackelford - bug 40255	10	# John-Mason P. Shackelford - bug 40255
		11	# Dakshinamurthy Karra - TemplatesPage support
11	###############################################################################	12	###############################################################################
12		13
13	ContentAssistProposal.label=Content &Assist@Ctrl+Space	14	ContentAssistProposal.label=Content &Assist@Ctrl+Space
Lines 41-43 Link Here
41	AntAnnotationHover.multipleMarkersAtThisLine=Multiple markers at this line	42	AntAnnotationHover.multipleMarkersAtThisLine=Multiple markers at this line
42		43
43	AntEditor.3=Current text selection does not resolve to an Ant reference	44	AntEditor.3=Current text selection does not resolve to an Ant reference
		45
		46	Editor.Paste.label=&Paste
		47	Editor.Paste.tooltip=Paste
		48	Editor.Paste.image=
		49	Editor.Paste.description=Paste




 * 	   IBM Corporation - bug fixes
 * 	   John-Mason P. Shackelford - bug 40255
 *     Mark Melvin - bug 93378
 *     Dakshinamurthy Karra - TemplatesView support
 *******************************************************************************/

package org.eclipse.ant.internal.ui.editor;

import org.eclipse.ant.internal.ui.editor.actions.RunToLineAdapter;
import org.eclipse.ant.internal.ui.editor.actions.ToggleLineBreakpointAction;
import org.eclipse.ant.internal.ui.editor.outline.AntEditorContentOutlinePage;
import org.eclipse.ant.internal.ui.editor.templates.AntTemplatesPage;
import org.eclipse.ant.internal.ui.editor.text.AntEditorDocumentProvider;
import org.eclipse.ant.internal.ui.editor.text.AntFoldingStructureProvider;
import org.eclipse.ant.internal.ui.editor.text.IReconcilingParticipant;

import org.eclipse.jface.text.ISelectionValidator;
import org.eclipse.jface.text.ISynchronizable;
import org.eclipse.jface.text.ITextInputListener;
import org.eclipse.jface.text.ITextOperationTarget;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Position;

import org.eclipse.jface.text.source.projection.IProjectionListener;
import org.eclipse.jface.text.source.projection.ProjectionSupport;
import org.eclipse.jface.text.source.projection.ProjectionViewer;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.IPostSelectionProvider;
import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.graphics.Image;

import org.eclipse.ui.texteditor.ContentAssistAction;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.IEditorStatusLine;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.ITextEditorActionConstants;
import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;
import org.eclipse.ui.texteditor.TextEditorAction;
import org.eclipse.ui.texteditor.TextOperationAction;
import org.eclipse.ui.texteditor.templates.TemplateTransfer;
import org.eclipse.ui.views.contentoutline.ContentOutline;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
import org.eclipse.ui.views.templates.ITemplatesPage;

/**
 * The actual editor implementation for Eclipse's Ant integration.
 */
public class AntEditor extends TextEditor implements IReconcilingParticipant, IProjectionListener {

	/**
	 * Clipboard paste operation support for templates
	 * 
	 * @since 3.4
	 */
	class ClipboardPasteOperation extends TextEditorAction {
		private ITextOperationTarget fOperationTarget;
		private int fOperationCode = -1;

		protected ClipboardPasteOperation(ResourceBundle bundle, String prefix, ITextEditor editor,
				int style) {
			super(bundle, prefix, editor, style);
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.action.Action#run()
		 */
		public void run() {
			ITextEditor editor = getTextEditor();
			Clipboard clipboard = new Clipboard(getSite().getShell().getDisplay());
			Template[] templates = (Template[]) clipboard.getContents(TemplateTransfer
					.getInstance());
			if (templates != null) {
				AntTemplatesPage page = (AntTemplatesPage) editor.getAdapter(ITemplatesPage.class);
				page.insertTemplate(templates[0]);
			} else
				fOperationTarget.doOperation(fOperationCode);
		}
	}


	/**
	 * Updates the Ant outline page selection and this editor's range indicator.
	 * 

     * The page that shows the outline.
     */
    protected AntEditorContentOutlinePage fOutlinePage;
	/**
	 * The templates page
     *
	 * @since 3.4
	 */
	protected AntTemplatesPage fTemplatesPage;
	
	private boolean fInitialReconcile= true;
	

		action= new RenameInFileAction(this);
		action.setActionDefinitionId("org.eclipse.ant.ui.renameInFile"); //$NON-NLS-1$
		setAction("renameInFile", action); //$NON-NLS-1$
		
		// Override the TextEditor paste operation to support templates
		action = new ClipboardPasteOperation(bundle,
				"Editor.Paste.", this, ITextOperationTarget.PASTE); //$NON-NLS-1$
		action.setActionDefinitionId(IWorkbenchActionDefinitionIds.PASTE);
		setAction(ITextEditorActionConstants.PASTE, action);
    }

	/*

			return getOutlinePage();
        }
        
		if (key.equals(ITemplatesPage.class)) {
			return getTemplatesPage();
		}

        if (fProjectionSupport != null) { 
        	Object adapter= fProjectionSupport.getAdapter(getSourceViewer(), key); 
        	if (adapter != null) {

		return fOutlinePage;
	}

	/**
	 * @since 3.4
	 * 
	 * @return the templatespage for this editor
	 */
	private AntTemplatesPage getTemplatesPage() {
		if (fTemplatesPage == null) {
			fTemplatesPage = new AntTemplatesPage(this);
		}
		return fTemplatesPage;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.AbstractTextEditor#handleCursorPositionChanged()
	 * 
	 * @since 3.4
	 */
	protected void handleCursorPositionChanged() {
		super.handleCursorPositionChanged();
		if (fTemplatesPage != null)
			fTemplatesPage.cursorPositionChanged();
	}

    private void doSelectionChanged(SelectionChangedEvent selectionChangedEvent) {
        IStructuredSelection selection= (IStructuredSelection)selectionChangedEvent.getSelection();





/*******************************************************************************
 * Copyright (c) 2000, 2007  Dakshinamurthy Karra 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:
 * 	   Dakshinamurthy Karra - Initial API and implementation
 *******************************************************************************/
package org.eclipse.ant.internal.ui.editor.templates;

import org.eclipse.ant.internal.ui.AntUIPlugin;
import org.eclipse.ant.internal.ui.editor.AntEditor;
import org.eclipse.ant.internal.ui.editor.formatter.FormattingPreferences;
import org.eclipse.ant.internal.ui.editor.formatter.XmlFormatter;
import org.eclipse.ant.internal.ui.editor.text.AntDocumentSetupParticipant;
import org.eclipse.ant.internal.ui.preferences.AntEditorPreferenceConstants;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.text.source.SourceViewerConfiguration;
import org.eclipse.jface.text.templates.ContextTypeRegistry;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.text.templates.TemplateContextType;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.texteditor.templates.TemplatesPage;
import org.eclipse.ui.views.templates.ITemplatesPage;

/**
 * An implementation of TemplatesPage for AntEditor
 * 
 * @see TemplatesPage
 * @since 3.4
 */
public class AntTemplatesPage extends TemplatesPage implements ITemplatesPage {

	private static final ContextTypeRegistry CONTEXT_TYPE_REGISTRY = AntTemplateAccess
			.getDefault().getContextTypeRegistry();
	private FormattingPreferences fFormattingPreferences = new FormattingPreferences();
	private final AntEditor fEditor;
	private String fCurrentId;

	/**
	 * Constructor
	 * 
	 * @param editor
	 */
	public AntTemplatesPage(AntEditor editor) {
		super(AntTemplateAccess.getDefault().getTemplateStore(),
				AntUIPlugin.getDefault().getPreferenceStore(), CONTEXT_TYPE_REGISTRY);
		fEditor = editor;
		cursorPositionChanged();
		setupEditorDropTarget(fEditor.getSite(), fEditor.getViewer()
				.getTextWidget());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.texteditor.templates.TemplatePreferencePage#createViewer(org.eclipse.swt.widgets.Composite)
	 */
	protected SourceViewer createViewer(Composite parent) {
		SourceViewer viewer = new SourceViewer(parent, null, SWT.BORDER
				| SWT.V_SCROLL | SWT.H_SCROLL);

		SourceViewerConfiguration configuration = new AntTemplateViewerConfiguration();
		IDocument document = new Document();
		new AntDocumentSetupParticipant().setup(document);
		viewer.configure(configuration);
		viewer.setDocument(document);
		viewer.setEditable(false);
		Font font = JFaceResources.getFont(JFaceResources.TEXT_FONT);
		viewer.getTextWidget().setFont(font);

		return viewer;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.texteditor.templates.TemplatePreferencePage#getFormatterPreferenceKey()
	 */
	protected String getFormatterPreferenceKey() {
		return AntEditorPreferenceConstants.TEMPLATES_USE_CODEFORMATTER;
	}

	/*
	 * @see org.eclipse.ui.texteditor.templates.TemplatePreferencePage#updateViewerInput()
	 */
	protected void updateViewerInput(Template template) {
		SourceViewer viewer = getViewer();

		if (AntUIPlugin.getDefault().getPreferenceStore().getBoolean(
				getFormatterPreferenceKey())) {
			String formatted = XmlFormatter.format(template.getPattern(),
					fFormattingPreferences);
			viewer.getDocument().set(formatted);
		} else {
			viewer.getDocument().set(template.getPattern());
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#getPreferencePageId()
	 */
	protected String getPreferencePageId() {
		return "org.eclipse.ant.ui.TemplatesPreferencePage"; //$NON-NLS-1$
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#insertTemplate(org.eclipse.jface.text.templates.Template)
	 */
	public void insertTemplate(Template template) {
		if (!fEditor.validateEditorInputState())
			return ;
		IRegion region;
		TemplateContextType type = CONTEXT_TYPE_REGISTRY
				.getContextType(template.getContextTypeId());
		if (type == null)
			return;
		ISourceViewer contextViewer = fEditor.getViewer();
		ITextSelection textSelection = (ITextSelection) contextViewer
				.getSelectionProvider().getSelection();
		region = new Region(textSelection.getOffset(), textSelection
				.getLength());
		Point selection = contextViewer.getSelectedRange();
		Position position;
		if (selection.y > 0) {
			position = new Position(selection.x, selection.y);
		} else {
			position = new Position(region.getOffset(), region.getLength());
		}

		IDocument document = contextViewer.getDocument();
		AntContext context = new AntContext(type, document, fEditor
				.getAntModel(), position);
		context.setVariable("selection", textSelection.getText()); //$NON-NLS-1$
		AntTemplateProposal proposal = new AntTemplateProposal(template,
				context, region, null, 100);
		fEditor.getSite().getPage().activate(fEditor);
		proposal.apply(fEditor.getViewer(), ' ', 0, region.getOffset());
	}

	/**
	 * Invoked by the editor whenever the caret position is updated
	 */
	public void cursorPositionChanged() {
		String id= getContextId();
		if (id.equals(fCurrentId))
			return;
		fCurrentId = id;
		if (fCurrentId.equals(BuildFileContextType.BUILDFILE_CONTEXT_TYPE))
			contextTypeChanged(new String[] { BuildFileContextType.BUILDFILE_CONTEXT_TYPE });
		else
			contextTypeChanged(new String[] {
					TargetContextType.TARGET_CONTEXT_TYPE,
					TaskContextType.TASK_CONTEXT_TYPE });
	}

	/**
	 * Get the contextid for the editor
	 * 
	 * @return contextId
	 */
	private String getContextId() {
		if (fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput())
				.getLength() == 0)
			return BuildFileContextType.BUILDFILE_CONTEXT_TYPE;
		return TargetContextType.TARGET_CONTEXT_TYPE;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#isValidTempalteForPosition(org.eclipse.jface.text.templates.Template, int, int)
	 */
	protected boolean isValidTemplateForPosition(Template template, int x, int y) {
		return getContextId().equals(template.getContextTypeId());
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.templates.TemplatesPage#isEditorModifiable()
	 */
	protected boolean isEditorModifiable() {
		return fEditor.isEditorInputModifiable();
	}
}

Return to bug 69581

Lines 7-12 Link Here

(-)ui/org/eclipse/jdt/internal/ui/javaeditor/JavaEditor.java (+26 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Dakshinamurthy Karra - TemplatesPage support (bug 69581)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.javaeditor;	12	package org.eclipse.jdt.internal.ui.javaeditor;
12		13
Lines 141-146 Link Here
141		142
142	import org.eclipse.ui.views.contentoutline.ContentOutline;	143	import org.eclipse.ui.views.contentoutline.ContentOutline;
143	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;	144	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
		145	import org.eclipse.ui.views.templates.ITemplatesPage;
144		146
145	import org.eclipse.jdt.core.IClassFile;	147	import org.eclipse.jdt.core.IClassFile;
146	import org.eclipse.jdt.core.ICompilationUnit;	148	import org.eclipse.jdt.core.ICompilationUnit;
Lines 194-199 Link Here
194	import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectNextAction;	196	import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectNextAction;
195	import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectPreviousAction;	197	import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectPreviousAction;
196	import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectionAction;	198	import org.eclipse.jdt.internal.ui.javaeditor.selectionactions.StructureSelectionAction;
		199	import org.eclipse.jdt.internal.ui.preferences.JavaTemplatesPage;
197	import org.eclipse.jdt.internal.ui.search.BreakContinueTargetFinder;	200	import org.eclipse.jdt.internal.ui.search.BreakContinueTargetFinder;
198	import org.eclipse.jdt.internal.ui.search.ExceptionOccurrencesFinder;	201	import org.eclipse.jdt.internal.ui.search.ExceptionOccurrencesFinder;
199	import org.eclipse.jdt.internal.ui.search.ImplementOccurrencesFinder;	202	import org.eclipse.jdt.internal.ui.search.ImplementOccurrencesFinder;
Lines 1333-1338 Link Here
1333	protected JavaOutlinePage fOutlinePage;	1336	protected JavaOutlinePage fOutlinePage;
1334	/** Outliner context menu Id */	1337	/** Outliner context menu Id */
1335	protected String fOutlinerContextMenuId;	1338	protected String fOutlinerContextMenuId;
		1339	/** The templates page
		1340	*
		1341	* @since 3.4
		1342	*/
		1343	private JavaTemplatesPage fTemplatesPage;
		1344
1336	/**	1345	/**
1337	* The editor selection changed listener.	1346	* The editor selection changed listener.
1338	*	1347	*
Lines 1778-1783 Link Here
1778	return fOutlinePage;	1787	return fOutlinePage;
1779	}	1788	}
1780		1789
		1790	if (required.equals(ITemplatesPage.class)) {
		1791	return getTemplatesPage();
		1792	}
		1793
1781	if (IEncodingSupport.class.equals(required))	1794	if (IEncodingSupport.class.equals(required))
1782	return fEncodingSupport;	1795	return fEncodingSupport;
1783		1796
Lines 1833-1838 Link Here
1833	}	1846	}
1834		1847
1835	/**	1848	/**
		1849	* @since 3.4
		1850	*/
		1851	private JavaTemplatesPage getTemplatesPage() {
		1852	if (fTemplatesPage == null) {
		1853	fTemplatesPage= new JavaTemplatesPage(this);
		1854
		1855	}
		1856	return fTemplatesPage;
		1857	}
		1858
		1859	/**
1836	* React to changed selection.	1860	* React to changed selection.
1837	*	1861	*
1838	* @since 3.0	1862	* @since 3.0
Lines 3225-3230 Link Here
3225	protected void handleCursorPositionChanged() {	3249	protected void handleCursorPositionChanged() {
3226	super.handleCursorPositionChanged();	3250	super.handleCursorPositionChanged();
3227	fCachedSelectedRange= getViewer().getSelectedRange();	3251	fCachedSelectedRange= getViewer().getSelectedRange();
		3252	if (fTemplatesPage != null)
		3253	fTemplatesPage.cursorPositionChanged();
3228	}	3254	}
3229		3255
3230	private static boolean isBracket(char character) {	3256	private static boolean isBracket(char character) {

Lines 45-51 Link Here

(-)ui/org/eclipse/jdt/internal/ui/JavaPerspectiveFactory.java (-1 / +4 lines)
45	outputfolder.addPlaceholder(IPageLayout.ID_BOOKMARKS);	45	outputfolder.addPlaceholder(IPageLayout.ID_BOOKMARKS);
46	outputfolder.addPlaceholder(IProgressConstants.PROGRESS_VIEW_ID);	46	outputfolder.addPlaceholder(IProgressConstants.PROGRESS_VIEW_ID);
47		47
48	layout.addView(IPageLayout.ID_OUTLINE, IPageLayout.RIGHT, (float)0.75, editorArea);	48	IFolderLayout outlineFolder = layout.createFolder("right", IPageLayout.RIGHT, (float)0.75, editorArea); //$NON-NLS-1$
		49	outlineFolder.addView(IPageLayout.ID_OUTLINE);
		50	outlineFolder.addView(IPageLayout.ID_TEMPLATES);
49		51
50	layout.addActionSet(IDebugUIConstants.LAUNCH_ACTION_SET);	52	layout.addActionSet(IDebugUIConstants.LAUNCH_ACTION_SET);
51	layout.addActionSet(JavaUI.ID_ACTION_SET);	53	layout.addActionSet(JavaUI.ID_ACTION_SET);
Lines 66-71 Link Here
66		68
67	// views - standard workbench	69	// views - standard workbench
68	layout.addShowViewShortcut(IPageLayout.ID_OUTLINE);	70	layout.addShowViewShortcut(IPageLayout.ID_OUTLINE);
		71	layout.addShowViewShortcut(IPageLayout.ID_TEMPLATES);
69	layout.addShowViewShortcut(IPageLayout.ID_PROBLEM_VIEW);	72	layout.addShowViewShortcut(IPageLayout.ID_PROBLEM_VIEW);
70	layout.addShowViewShortcut(IPageLayout.ID_RES_NAV);	73	layout.addShowViewShortcut(IPageLayout.ID_RES_NAV);
71	layout.addShowViewShortcut(IPageLayout.ID_TASK_LIST);	74	layout.addShowViewShortcut(IPageLayout.ID_TASK_LIST);

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/preferences/JavaTemplatesPage.java (+439 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 Dakshinamurthy Karra 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	* Dakshinamurthy Karra - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.preferences;
12
13	import org.eclipse.jdt.core.ICompilationUnit;
14	import org.eclipse.jdt.core.JavaCore;
15	import org.eclipse.jdt.internal.corext.template.java.CompilationUnitContextType;
16	import org.eclipse.jdt.internal.corext.template.java.JavaContext;
17	import org.eclipse.jdt.internal.corext.template.java.JavaContextType;
18	import org.eclipse.jdt.internal.corext.template.java.JavaDocContext;
19	import org.eclipse.jdt.internal.corext.template.java.JavaDocContextType;
20	import org.eclipse.jdt.internal.ui.JavaPlugin;
21	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
22	import org.eclipse.jdt.internal.ui.javaeditor.JavaSourceViewer;
23	import org.eclipse.jdt.internal.ui.text.SimpleJavaSourceViewerConfiguration;
24	import org.eclipse.jdt.internal.ui.text.template.contentassist.TemplateProposal;
25	import org.eclipse.jdt.internal.ui.text.template.preferences.TemplateVariableProcessor;
26	import org.eclipse.jdt.ui.PreferenceConstants;
27	import org.eclipse.jdt.ui.text.IJavaPartitions;
28	import org.eclipse.jdt.ui.text.JavaTextTools;
29	import org.eclipse.jface.preference.IPreferenceStore;
30	import org.eclipse.jface.resource.JFaceResources;
31	import org.eclipse.jface.text.BadLocationException;
32	import org.eclipse.jface.text.Document;
33	import org.eclipse.jface.text.IDocument;
34	import org.eclipse.jface.text.ITextSelection;
35	import org.eclipse.jface.text.ITextViewerExtension;
36	import org.eclipse.jface.text.ITextViewerExtension5;
37	import org.eclipse.jface.text.Position;
38	import org.eclipse.jface.text.Region;
39	import org.eclipse.jface.text.TextSelection;
40	import org.eclipse.jface.text.TextUtilities;
41	import org.eclipse.jface.text.source.ISourceViewer;
42	import org.eclipse.jface.text.source.SourceViewer;
43	import org.eclipse.jface.text.templates.ContextTypeRegistry;
44	import org.eclipse.jface.text.templates.DocumentTemplateContext;
45	import org.eclipse.jface.text.templates.Template;
46	import org.eclipse.jface.text.templates.TemplateContextType;
47	import org.eclipse.jface.window.Window;
48	import org.eclipse.swt.SWT;
49	import org.eclipse.swt.custom.StyledText;
50	import org.eclipse.swt.graphics.Font;
51	import org.eclipse.swt.graphics.Point;
52	import org.eclipse.swt.layout.GridData;
53	import org.eclipse.swt.widgets.Composite;
54	import org.eclipse.swt.widgets.Control;
55	import org.eclipse.ui.part.FileEditorInput;
56	import org.eclipse.ui.texteditor.templates.TemplatesPage;
57	import org.eclipse.ui.views.templates.ITemplatesPage;
58
59	/**
60	* A TemplatesPage implementation for JavaEditor
61	*
62	* @since 3.4
63	*/
64	public class JavaTemplatesPage extends TemplatesPage implements ITemplatesPage {
65
66	private final class JavaDocContextExtension extends JavaDocContext {
67	private final Template fTemplate;
68	private final boolean fOverrideGetKey;
69
70	private JavaDocContextExtension(IDocument document, Position completionPosition, Template template, boolean overrideGetKey) {
71	super(CONTEXT_REGISTRY.getContextType(template.getContextTypeId()),
72	document,
73	completionPosition, JavaCore.createCompilationUnitFrom(((FileEditorInput) fEditor.getEditorInput()).getFile()));
74	fTemplate = template;
75	fOverrideGetKey = overrideGetKey;
76	}
77
78	public String getKey() {
79	String key = super.getKey();
80	if (!fOverrideGetKey)
81	return key ;
82	try {
83	int offset ;
84	if (key.equals("") && (offset = getCompletionOffset()) > 0 && Character.isWhitespace(getDocument().getChar(offset - 1))) //$NON-NLS-1$
85	return fTemplate.getName().substring(0, 1);
86	} catch (BadLocationException e) {
87	}
88	return key ;
89	}
90	}
91
92	private final class JavaContextExtension extends JavaContext {
93	private final boolean fOverrideGetKey;
94	private final Template fTemplate;
95
96	private JavaContextExtension(IDocument document, Position completionPosition,
97	Template template, boolean overrideGetKey) {
98	super(CONTEXT_REGISTRY.getContextType(template.getContextTypeId()),
99	document,
100	completionPosition, JavaCore.createCompilationUnitFrom(((FileEditorInput) fEditor.getEditorInput()).getFile()));
101	fOverrideGetKey = overrideGetKey;
102	fTemplate = template;
103	}
104
105	public String getKey() {
106	String key = super.getKey();
107	if (!fOverrideGetKey)
108	return key ;
109	try {
110	int offset ;
111	if (key.equals("") && (offset = getCompletionOffset()) > 0 && !isTempalteNamePart(getDocument().getChar(offset - 1))) //$NON-NLS-1$
112	return fTemplate.getName().substring(0, 1);
113	} catch (BadLocationException e) {
114	}
115	return key ;
116	}
117
118	/**
119	* Copied from JavaContext
120	* @param ch
121	* @return true if ch can be a part of a templates name
122	*/
123	private boolean isTempalteNamePart(char ch) {
124	return !Character.isWhitespace(ch) && ch != '(' && ch != ')' && ch != '{' && ch != '}' && ch != ';';
125	}
126	}
127
128	private static final ContextTypeRegistry CONTEXT_REGISTRY= JavaPlugin.getDefault().getTemplateContextRegistry();
129	private TemplateVariableProcessor fTemplateProcessor;
130	private final JavaEditor fEditor;
131	private String fJavaDocId;
132	private String fJavaId;
133	private String fCurrentId;
134	private int fCachedOffset;
135	private boolean fCachedResult;
136	private Point fCachedPosition;
137
138	/**
139	* @param javaEditor
140	*/
141	public JavaTemplatesPage(JavaEditor javaEditor) {
142	super(JavaPlugin.getDefault().getTemplateStore(), JavaPlugin.getDefault().getPreferenceStore(), CONTEXT_REGISTRY);
143	fEditor= javaEditor;
144	fJavaDocId= new JavaDocContextType().getId();
145	fJavaId= new JavaContextType().getId();
146	fTemplateProcessor= new TemplateVariableProcessor();
147	cursorPositionChanged();
148	setupEditorDropTarget(fEditor.getSite(), fEditor.getViewer().getTextWidget());
149	}
150
151	public void dispose() {
152	super.dispose();
153	}
154
155	/* (non-Javadoc)
156	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#editTemplate(org.eclipse.jface.text.templates.Template, boolean, boolean)
157	*/
158	protected Template editTemplate(Template template, boolean edit, boolean isNameModifiable) {
159	EditTemplateDialog dialog= new EditTemplateDialog(getShell(), template, edit, isNameModifiable, CONTEXT_REGISTRY);
160	if (dialog.open() == Window.OK) {
161	return dialog.getTemplate();
162	}
163	return null;
164	}
165
166	/* (non-Javadoc)
167	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#createViewer(org.eclipse.swt.widgets.Composite)
168	*/
169	protected SourceViewer createViewer(Composite parent) {
170	IDocument document= new Document();
171	JavaTextTools tools= JavaPlugin.getDefault().getJavaTextTools();
172	tools.setupJavaDocumentPartitioner(document, IJavaPartitions.JAVA_PARTITIONING);
173	IPreferenceStore store= JavaPlugin.getDefault().getCombinedPreferenceStore();
174	SourceViewer viewer= new JavaSourceViewer(parent, null, null, false, SWT.BORDER \| SWT.V_SCROLL \| SWT.H_SCROLL, store);
175	SimpleJavaSourceViewerConfiguration configuration= new SimpleJavaSourceViewerConfiguration(tools.getColorManager(), store, null, IJavaPartitions.JAVA_PARTITIONING, false);
176	viewer.configure(configuration);
177	viewer.setEditable(false);
178	viewer.setDocument(document);
179
180	Font font= JFaceResources.getFont(PreferenceConstants.EDITOR_TEXT_FONT);
181	viewer.getTextWidget().setFont(font);
182	new JavaSourcePreviewerUpdater(viewer, configuration, store);
183
184	Control control= viewer.getControl();
185	GridData data= new GridData(GridData.HORIZONTAL_ALIGN_FILL \| GridData.FILL_VERTICAL);
186	control.setLayoutData(data);
187
188	return viewer;
189	}
190
191
192	/* (non-Javadoc)
193	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#updateViewerInput(org.eclipse.jface.text.templates.Template)
194	*/
195	protected void updateViewerInput(Template template) {
196	SourceViewer viewer= getViewer();
197
198	String contextId= template.getContextTypeId();
199	TemplateContextType type= CONTEXT_REGISTRY.getContextType(contextId);
200	fTemplateProcessor.setContextType(type);
201
202	IDocument doc= viewer.getDocument();
203
204	String start= null;
205	if ("javadoc".equals(contextId)) { //$NON-NLS-1$
206	start= "/**" + doc.getLegalLineDelimiters()[0]; //$NON-NLS-1$
207	} else
208	start= ""; //$NON-NLS-1$
209
210	doc.set(start + template.getPattern());
211	int startLen= start.length();
212	viewer.setDocument(doc, startLen, doc.getLength() - startLen);
213	}
214
215	/* (non-Javadoc)
216	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#getPreferencePageId()
217	*/
218	protected String getPreferencePageId() {
219	return "org.eclipse.jdt.ui.preferences.JavaTemplatePreferencePage"; //$NON-NLS-1$
220	}
221
222	/* (non-Javadoc)
223	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#insertTemplate(org.eclipse.jface.text.templates.Template)
224	*/
225	public void insertTemplate(Template template) {
226	if (!fEditor.validateEditorInputState())
227	return ;
228	ISourceViewer contextViewer= fEditor.getViewer();
229	ITextSelection textSelection= (ITextSelection) contextViewer.getSelectionProvider().getSelection();
230	IDocument document = fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput());
231	if ( !isValidTemplate(document, template, textSelection.getOffset(), textSelection.getLength()))
232	return;
233	beginCompoundChange(contextViewer);
234	/*
235	* The Editor checks whether a completion for a word exists before it allows for the template to be
236	* applied. We pickup the current text at the selection position and replace it with the first char
237	* of the template name for this to succeed.
238	* Another advantage by this method is that the template replaces the selected text provided the
239	* selection by itself is not used in the template pattern.
240	*/
241	String savedText;
242	try {
243	savedText= document.get(textSelection.getOffset(), textSelection.getLength());
244	if (savedText.length() == 0) {
245	String prefix = getIdentifierPart(document, template, textSelection.getOffset(), textSelection.getLength());
246	if (prefix.length() > 0 && !template.getName().startsWith(prefix.toString())) {
247	return;
248	}
249	if (prefix.length() > 0) {
250	contextViewer.setSelectedRange(textSelection.getOffset() - prefix.length(), prefix.length());
251	textSelection= (ITextSelection) contextViewer.getSelectionProvider().getSelection();
252	}
253	}
254	document.replace(textSelection.getOffset(), textSelection.getLength(), template.getName().substring(0, 1));
255	} catch (BadLocationException e) {
256	endCompoundChange(contextViewer);
257	return;
258	}
259	Position position= new Position(textSelection.getOffset() + 1, 0);
260	Region region= new Region(textSelection.getOffset() + 1, 0);
261	contextViewer.getSelectionProvider().setSelection(new TextSelection(textSelection.getOffset(), 1));
262	ICompilationUnit compilationUnit= JavaCore.createCompilationUnitFrom(((FileEditorInput) fEditor.getEditorInput()).getFile());
263
264	TemplateContextType type= CONTEXT_REGISTRY.getContextType(template.getContextTypeId());
265	DocumentTemplateContext context= ((CompilationUnitContextType) type).createContext(document, position, compilationUnit);
266	context.setVariable("selection", savedText); //$NON-NLS-1$
267	if (context.getKey().length() == 0) {
268	try {
269	document.replace(textSelection.getOffset(), 1, savedText);
270	} catch (BadLocationException e) {
271	endCompoundChange(contextViewer);
272	return;
273	}
274	}
275	TemplateProposal proposal= new TemplateProposal(template, context, region, null);
276	fEditor.getSite().getPage().activate(fEditor);
277	proposal.apply(fEditor.getViewer(), ' ', 0, region.getOffset());
278	endCompoundChange(contextViewer);
279	}
280
281	/**
282	* Undomanager - end compound change
283	* @param viewer
284	*/
285	private void endCompoundChange(ISourceViewer viewer) {
286	if (viewer instanceof ITextViewerExtension)
287	((ITextViewerExtension)viewer).getRewriteTarget().endCompoundChange();
288	}
289
290	/**
291	* Undomanager - begin a compound change
292	* @param viewer
293	*/
294	private void beginCompoundChange(ISourceViewer viewer) {
295	if (viewer instanceof ITextViewerExtension)
296	((ITextViewerExtension)viewer).getRewriteTarget().beginCompoundChange();
297	}
298
299	/**
300	* Invoked by the editor whenever the caret position is updated
301	*/
302	public void cursorPositionChanged() {
303	Point selectedRange= fEditor.getViewer().getSelectedRange();
304	int cursor= selectedRange.x + selectedRange.y;
305	String partition;
306	try {
307	IDocument document = fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput());
308	partition= TextUtilities.getContentType(document, IJavaPartitions.JAVA_PARTITIONING, cursor, true);
309	} catch (BadLocationException e) {
310	return;
311	}
312	String id= fJavaId;
313	if (partition.equals(IJavaPartitions.JAVA_DOC))
314	id= fJavaDocId;
315	if (!id.equals(fCurrentId)) {
316	fCurrentId= id;
317	contextTypeChanged(new String[] { id });
318	}
319	}
320
321	/* (non-Javadoc)
322	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#isValidTempalteForPosition(org.eclipse.jface.text.templates.Template, int, int)
323	*/
324	protected boolean isValidTemplateForPosition(Template template, int x, int y) {
325	StyledText textWidget= fEditor.getViewer().getTextWidget();
326	IDocument document = fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput());
327	try {
328	Point point= new Point(x,y);
329	if (point.equals(fCachedPosition))
330	return fCachedResult;
331	fCachedPosition = point ;
332	int offset= getOffset(document, textWidget, textWidget.toControl(x, y));
333	if (fCachedOffset == offset)
334	return fCachedResult;
335	fCachedOffset= offset;
336	if (isValidTemplate(document, template, offset, 0))
337	return fCachedResult= true;
338	} catch (BadLocationException e) {
339	}
340	return fCachedResult= false;
341	}
342
343	/**
344	* Get the document relative offset from the textwidget relative point
345	*
346	* @param document
347	* @param textWidget
348	* @param point
349	* @return the offset
350	* @throws BadLocationException
351	*/
352	private int getOffset(IDocument document, StyledText textWidget, Point point) throws BadLocationException {
353	ITextViewerExtension5 ext= (ITextViewerExtension5) fEditor.getViewer();
354	try {
355	return ext.widgetOffset2ModelOffset(textWidget.getOffsetAtLocation(point));
356	} catch (IllegalArgumentException e) {
357	int docLineIndex= ext.widgetLine2ModelLine(textWidget.getLineIndex(point.y));
358	String lineDelimiter= document.getLineDelimiter(docLineIndex);
359	int delimLength= lineDelimiter == null ? 0 : lineDelimiter.length();
360	return document.getLineOffset(docLineIndex) + document.getLineLength(docLineIndex) - delimLength;
361	}
362	}
363
364	/**
365	* Check whether the template is valid for the given offset
366	* @param document
367	* @param template
368	* @param offset
369	* @param length
370	* @return true if the template is valid
371	*/
372	private boolean isValidTemplate(IDocument document, Template template, int offset, int length) {
373	try {
374	if (!getContextId(document, offset).equals(template.getContextTypeId()))
375	return false ;
376	} catch (BadLocationException e) {
377	return false ;
378	}
379	DocumentTemplateContext context = getContextExtension(document, template, offset, length, true);
380	return context.canEvaluate(template);
381	}
382
383	/**
384	* Get context extension
385	*
386	* @param document
387	* @param template
388	* @param offset
389	* @param length
390	* @param overrideGetKey
391	* @return the contextextension
392	*/
393	private DocumentTemplateContext getContextExtension(IDocument document, Template template, final int offset,
394	int length, boolean overrideGetKey) {
395	DocumentTemplateContext context;
396	if (template.getContextTypeId().equals(fJavaId)) {
397	context = new JavaContextExtension(document, new Position(offset, length), template, overrideGetKey);
398	} else {
399	context = new JavaDocContextExtension(document, new Position(offset, length),template, overrideGetKey);
400	}
401	return context;
402	}
403
404	/**
405	* Get the context id for at the given offset
406	*
407	* @param document
408	* @param offset
409	* @return the context id
410	* @throws BadLocationException
411	*/
412	private String getContextId(IDocument document, int offset) throws BadLocationException {
413	String partition= TextUtilities.getContentType(document, IJavaPartitions.JAVA_PARTITIONING, offset, true);
414	String id= fJavaId;
415	if (partition.equals(IJavaPartitions.JAVA_DOC))
416	id= fJavaDocId;
417	return id;
418	}
419
420	/**
421	* Get the java identifier terminated at the given offset
422	* @param document
423	* @param template
424	* @param offset
425	* @param length
426	* @return the identifier part
427	* @throws BadLocationException
428	*/
429	private String getIdentifierPart(IDocument document, Template template, int offset, int length) throws BadLocationException {
430	return getContextExtension(document, template, offset, length, false).getKey();
431	}
432
433	/* (non-Javadoc)
434	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#isEditorModifiable()
435	*/
436	protected boolean isEditorModifiable() {
437	return fEditor.isEditorInputModifiable();
438	}
439	}

Added Link Here

(-)src/org/eclipse/ui/views/templates/Templates.java (+185 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 Dakshinamurthy Karra 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	* Dakshinamurthy Karra - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.ui.views.templates;
13
14	import org.eclipse.swt.widgets.Composite;
15	import org.eclipse.ui.IEditorPart;
16	import org.eclipse.ui.IWorkbenchPage;
17	import org.eclipse.ui.IWorkbenchPart;
18	import org.eclipse.ui.PlatformUI;
19	import org.eclipse.ui.internal.views.ViewsPlugin;
20	import org.eclipse.ui.internal.views.templates.TemplatesMessages;
21	import org.eclipse.ui.part.IContributedContentsView;
22	import org.eclipse.ui.part.IPage;
23	import org.eclipse.ui.part.MessagePage;
24	import org.eclipse.ui.part.PageBook;
25	import org.eclipse.ui.part.PageBookView;
26
27	/**
28	* Main class for the Templates View.
29	* <p>
30	* This standard view has id <code>"org.eclipse.ui.views.TemplatesView"</code>.
31	* </p>
32	* When a <b>templates view</b> notices an editor being activated, it
33	* asks the editor whether it has a <b>template page</b> to include
34	* in the templates view. This is done using <code>getAdapter</code>:
35	* <pre>
36	* IEditorPart editor = ...;
37	* ITemplatePage templatePage = (ITemplatePage) editor.getAdapter(ITemplatePage.class);
38	* if (templatePage != null) {
39	* // editor wishes to contribute templatePage to templates view
40	* }
41	* </pre>
42	* If the editor supports a templates page, the editor instantiates
43	* and configures the page, and returns it. This page is then added to the
44	* templates view (a pagebook which presents one page at a time) and
45	* immediately made the current page (the templates view need not be
46	* visible). If the editor does not support a template page, the templates
47	* view shows a special default page which makes it clear to the user
48	* that the templates view is disengaged. When the templates view notices a
49	* different editor being activated, it flips to the editor's corresponding
50	* template page. When the templates view notices an editor being
51	* closed, it may destroy the editor's corresponding content outline page.
52	* </p>
53	* <p>
54	* The workbench will automatically instantiate this class when a templates
55	* view is needed for a workbench window. This class was not intended
56	* to be instantiated or subclassed by clients.
57	* </p>
58	*
59	* @since 3.4
60	*/
61	public class Templates extends PageBookView {
62	/**
63	* The plugin prefix.
64	*/
65	public static final String PREFIX = PlatformUI.PLUGIN_ID + "."; //$NON-NLS-1$
66
67	/**
68	* Help context id used for the content outline view
69	* (value <code>"org.eclipse.ui.content_outline_context"</code>).
70	*/
71	public static final String TEMPLATES_VIEW_HELP_CONTEXT_ID = PREFIX
72	+ "templates_view_context";//$NON-NLS-1$
73
74	/**
75	* Message to show on the default page.
76	*/
77	private String defaultText = TemplatesMessages.Templates_defaultMessage;
78
79	/**
80	* Creates a content outline view with no content outline pages.
81	*/
82	public Templates() {
83	super();
84	}
85
86	/* (non-Javadoc)
87	* Method declared on PageBookView.
88	*/
89	protected IPage createDefaultPage(PageBook book) {
90	MessagePage page = new MessagePage();
91	initPage(page);
92	page.createControl(book);
93	page.setMessage(defaultText);
94	return page;
95	}
96
97	/**
98	* The <code>PageBookView</code> implementation of this <code>IWorkbenchPart</code>
99	* method creates a <code>PageBook</code> control with its default page showing.
100	*/
101	public void createPartControl(Composite parent) {
102	super.createPartControl(parent);
103	PlatformUI.getWorkbench().getHelpSystem().setHelp(getPageBook(),
104	TEMPLATES_VIEW_HELP_CONTEXT_ID);
105	}
106
107	/* (non-Javadoc)
108	* Method declared on PageBookView.
109	*/
110	protected PageRec doCreatePage(IWorkbenchPart part) {
111	// Try to get template page.
112	Object obj = ViewsPlugin.getAdapter(part, ITemplatesPage.class, false);
113	if (obj instanceof ITemplatesPage) {
114	ITemplatesPage page = (ITemplatesPage) obj;
115	initPage(page);
116	page.createControl(getPageBook());
117	return new PageRec(part, page);
118	}
119	// There is no template page
120	return null;
121	}
122
123	/* (non-Javadoc)
124	* Method declared on PageBookView.
125	*/
126	protected void doDestroyPage(IWorkbenchPart part, PageRec rec) {
127	ITemplatesPage page = (ITemplatesPage) rec.page;
128	page.dispose();
129	rec.dispose();
130	}
131
132	/* (non-Javadoc)
133	* Method declared on IAdaptable.
134	*/
135	public Object getAdapter(Class key) {
136	if (key == IContributedContentsView.class) {
137	return new IContributedContentsView() {
138	public IWorkbenchPart getContributingPart() {
139	return getContributingEditor();
140	}
141	};
142	}
143	return super.getAdapter(key);
144	}
145
146	/* (non-Javadoc)
147	* Method declared on PageBookView.
148	*/
149	protected IWorkbenchPart getBootstrapPart() {
150	IWorkbenchPage page = getSite().getPage();
151	if (page != null) {
152	return page.getActiveEditor();
153	}
154
155	return null;
156	}
157
158	/**
159	* Returns the editor which contributed the current
160	* page to this view.
161	*
162	* @return the editor which contributed the current page
163	* or <code>null</code> if no editor contributed the current page
164	*/
165	private IWorkbenchPart getContributingEditor() {
166	return getCurrentContributingPart();
167	}
168
169	/* (non-Javadoc)
170	* Method declared on PageBookView.
171	* We only want to track editors.
172	*/
173	protected boolean isImportant(IWorkbenchPart part) {
174	//We only care about editors
175	return (part instanceof IEditorPart);
176	}
177
178	/* (non-Javadoc)
179	* Method declared on IViewPart.
180	* Treat this the same as part activation.
181	*/
182	public void partBroughtToTop(IWorkbenchPart part) {
183	partActivated(part);
184	}
185	}

Added Link Here

(-)src/org/eclipse/ui/views/templates/ITemplatesPage.java (+24 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 Dakshinamurthy Karra 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	* Dakshinamurthy Karra - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.views.templates;
12
13	import org.eclipse.ui.part.IPageBookViewPage;
14
15	/**
16	* Interface for a template page. This interface defines
17	* the minimum requirement for pages within the templates view, namely
18	* they must be pages (implement <code>IPageBookViewPage</code>).
19	*
20	* @see TemplatesView
21	* @since 3.4
22	*/
23	public interface ITemplatesPage extends IPageBookViewPage {
24	}

Lines 12-17 Link Here

(-)Ant Editor/org/eclipse/ant/internal/ui/editor/AntEditor.java (-1 / +81 lines)
12	* IBM Corporation - bug fixes	12	* IBM Corporation - bug fixes
13	* John-Mason P. Shackelford - bug 40255	13	* John-Mason P. Shackelford - bug 40255
14	* Mark Melvin - bug 93378	14	* Mark Melvin - bug 93378
		15	* Dakshinamurthy Karra - TemplatesView support
15	*******************************************************************************/	16	*******************************************************************************/
16		17
17	package org.eclipse.ant.internal.ui.editor;	18	package org.eclipse.ant.internal.ui.editor;
Lines 34-39 Link Here
34	import org.eclipse.ant.internal.ui.editor.actions.RunToLineAdapter;	35	import org.eclipse.ant.internal.ui.editor.actions.RunToLineAdapter;
35	import org.eclipse.ant.internal.ui.editor.actions.ToggleLineBreakpointAction;	36	import org.eclipse.ant.internal.ui.editor.actions.ToggleLineBreakpointAction;
36	import org.eclipse.ant.internal.ui.editor.outline.AntEditorContentOutlinePage;	37	import org.eclipse.ant.internal.ui.editor.outline.AntEditorContentOutlinePage;
		38	import org.eclipse.ant.internal.ui.editor.templates.AntTemplatesPage;
37	import org.eclipse.ant.internal.ui.editor.text.AntEditorDocumentProvider;	39	import org.eclipse.ant.internal.ui.editor.text.AntEditorDocumentProvider;
38	import org.eclipse.ant.internal.ui.editor.text.AntFoldingStructureProvider;	40	import org.eclipse.ant.internal.ui.editor.text.AntFoldingStructureProvider;
39	import org.eclipse.ant.internal.ui.editor.text.IReconcilingParticipant;	41	import org.eclipse.ant.internal.ui.editor.text.IReconcilingParticipant;
Lines 71-76 Link Here
71	import org.eclipse.jface.text.ISelectionValidator;	73	import org.eclipse.jface.text.ISelectionValidator;
72	import org.eclipse.jface.text.ISynchronizable;	74	import org.eclipse.jface.text.ISynchronizable;
73	import org.eclipse.jface.text.ITextInputListener;	75	import org.eclipse.jface.text.ITextInputListener;
		76	import org.eclipse.jface.text.ITextOperationTarget;
74	import org.eclipse.jface.text.ITextSelection;	77	import org.eclipse.jface.text.ITextSelection;
75	import org.eclipse.jface.text.ITextViewer;	78	import org.eclipse.jface.text.ITextViewer;
76	import org.eclipse.jface.text.Position;	79	import org.eclipse.jface.text.Position;
Lines 85-90 Link Here
85	import org.eclipse.jface.text.source.projection.IProjectionListener;	88	import org.eclipse.jface.text.source.projection.IProjectionListener;
86	import org.eclipse.jface.text.source.projection.ProjectionSupport;	89	import org.eclipse.jface.text.source.projection.ProjectionSupport;
87	import org.eclipse.jface.text.source.projection.ProjectionViewer;	90	import org.eclipse.jface.text.source.projection.ProjectionViewer;
		91	import org.eclipse.jface.text.templates.Template;
88	import org.eclipse.jface.util.PropertyChangeEvent;	92	import org.eclipse.jface.util.PropertyChangeEvent;
89	import org.eclipse.jface.viewers.IPostSelectionProvider;	93	import org.eclipse.jface.viewers.IPostSelectionProvider;
90	import org.eclipse.jface.viewers.ISelection;	94	import org.eclipse.jface.viewers.ISelection;
Lines 93-98 Link Here
93	import org.eclipse.jface.viewers.IStructuredSelection;	97	import org.eclipse.jface.viewers.IStructuredSelection;
94	import org.eclipse.jface.viewers.SelectionChangedEvent;	98	import org.eclipse.jface.viewers.SelectionChangedEvent;
95	import org.eclipse.swt.custom.StyledText;	99	import org.eclipse.swt.custom.StyledText;
		100	import org.eclipse.swt.dnd.Clipboard;
96	import org.eclipse.swt.events.ShellAdapter;	101	import org.eclipse.swt.events.ShellAdapter;
97	import org.eclipse.swt.events.ShellEvent;	102	import org.eclipse.swt.events.ShellEvent;
98	import org.eclipse.swt.graphics.Image;	103	import org.eclipse.swt.graphics.Image;
Lines 112-127 Link Here
112	import org.eclipse.ui.texteditor.ContentAssistAction;	117	import org.eclipse.ui.texteditor.ContentAssistAction;
113	import org.eclipse.ui.texteditor.IDocumentProvider;	118	import org.eclipse.ui.texteditor.IDocumentProvider;
114	import org.eclipse.ui.texteditor.IEditorStatusLine;	119	import org.eclipse.ui.texteditor.IEditorStatusLine;
		120	import org.eclipse.ui.texteditor.ITextEditor;
115	import org.eclipse.ui.texteditor.ITextEditorActionConstants;	121	import org.eclipse.ui.texteditor.ITextEditorActionConstants;
116	import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;	122	import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
		123	import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;
		124	import org.eclipse.ui.texteditor.TextEditorAction;
117	import org.eclipse.ui.texteditor.TextOperationAction;	125	import org.eclipse.ui.texteditor.TextOperationAction;
		126	import org.eclipse.ui.texteditor.templates.TemplateTransfer;
118	import org.eclipse.ui.views.contentoutline.ContentOutline;	127	import org.eclipse.ui.views.contentoutline.ContentOutline;
119	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;	128	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
		129	import org.eclipse.ui.views.templates.ITemplatesPage;
120		130
121	/**	131	/**
122	* The actual editor implementation for Eclipse's Ant integration.	132	* The actual editor implementation for Eclipse's Ant integration.
123	*/	133	*/
124	public class AntEditor extends TextEditor implements IReconcilingParticipant, IProjectionListener {	134	public class AntEditor extends TextEditor implements IReconcilingParticipant, IProjectionListener {
		135
		136	/**
		137	* Clipboard paste operation support for templates
		138	*
		139	* @since 3.4
		140	*/
		141	class ClipboardPasteOperation extends TextEditorAction {
		142	private ITextOperationTarget fOperationTarget;
		143	private int fOperationCode = -1;
		144
		145	protected ClipboardPasteOperation(ResourceBundle bundle, String prefix, ITextEditor editor,
		146	int style) {
		147	super(bundle, prefix, editor, style);
		148	}
		149
		150	/* (non-Javadoc)
		151	* @see org.eclipse.jface.action.Action#run()
		152	*/
		153	public void run() {
		154	ITextEditor editor = getTextEditor();
		155	Clipboard clipboard = new Clipboard(getSite().getShell().getDisplay());
		156	Template[] templates = (Template[]) clipboard.getContents(TemplateTransfer
		157	.getInstance());
		158	if (templates != null) {
		159	AntTemplatesPage page = (AntTemplatesPage) editor.getAdapter(ITemplatesPage.class);
		160	page.insertTemplate(templates[0]);
		161	} else
		162	fOperationTarget.doOperation(fOperationCode);
		163	}
		164	}
		165
		166
125	/**	167	/**
126	* Updates the Ant outline page selection and this editor's range indicator.	168	* Updates the Ant outline page selection and this editor's range indicator.
127	*	169	*
Lines 461-467 Link Here
461	* The page that shows the outline.	503	* The page that shows the outline.
462	*/	504	*/
463	protected AntEditorContentOutlinePage fOutlinePage;	505	protected AntEditorContentOutlinePage fOutlinePage;
464		506	/**
		507	* The templates page
		508	*
		509	* @since 3.4
		510	*/
		511	protected AntTemplatesPage fTemplatesPage;
465		512
466	private boolean fInitialReconcile= true;	513	private boolean fInitialReconcile= true;
467		514
Lines 538-543 Link Here
538	action= new RenameInFileAction(this);	585	action= new RenameInFileAction(this);
539	action.setActionDefinitionId("org.eclipse.ant.ui.renameInFile"); //$NON-NLS-1$	586	action.setActionDefinitionId("org.eclipse.ant.ui.renameInFile"); //$NON-NLS-1$
540	setAction("renameInFile", action); //$NON-NLS-1$	587	setAction("renameInFile", action); //$NON-NLS-1$
		588
		589	// Override the TextEditor paste operation to support templates
		590	action = new ClipboardPasteOperation(bundle,
		591	"Editor.Paste.", this, ITextOperationTarget.PASTE); //$NON-NLS-1$
		592	action.setActionDefinitionId(IWorkbenchActionDefinitionIds.PASTE);
		593	setAction(ITextEditorActionConstants.PASTE, action);
541	}	594	}
542		595
543	/*	596	/*
Lines 564-569 Link Here
564	return getOutlinePage();	617	return getOutlinePage();
565	}	618	}
566		619
		620	if (key.equals(ITemplatesPage.class)) {
		621	return getTemplatesPage();
		622	}
		623
567	if (fProjectionSupport != null) {	624	if (fProjectionSupport != null) {
568	Object adapter= fProjectionSupport.getAdapter(getSourceViewer(), key);	625	Object adapter= fProjectionSupport.getAdapter(getSourceViewer(), key);
569	if (adapter != null) {	626	if (adapter != null) {
Lines 599-604 Link Here
599	return fOutlinePage;	656	return fOutlinePage;
600	}	657	}
601		658
		659	/**
		660	* @since 3.4
		661	*
		662	* @return the templatespage for this editor
		663	*/
		664	private AntTemplatesPage getTemplatesPage() {
		665	if (fTemplatesPage == null) {
		666	fTemplatesPage = new AntTemplatesPage(this);
		667	}
		668	return fTemplatesPage;
		669	}
		670
		671	/* (non-Javadoc)
		672	* @see org.eclipse.ui.texteditor.AbstractTextEditor#handleCursorPositionChanged()
		673	*
		674	* @since 3.4
		675	*/
		676	protected void handleCursorPositionChanged() {
		677	super.handleCursorPositionChanged();
		678	if (fTemplatesPage != null)
		679	fTemplatesPage.cursorPositionChanged();
		680	}
		681
602	private void doSelectionChanged(SelectionChangedEvent selectionChangedEvent) {	682	private void doSelectionChanged(SelectionChangedEvent selectionChangedEvent) {
603	IStructuredSelection selection= (IStructuredSelection)selectionChangedEvent.getSelection();	683	IStructuredSelection selection= (IStructuredSelection)selectionChangedEvent.getSelection();
604		684

Added Link Here

(-)Ant (+199 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 Dakshinamurthy Karra 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	* Dakshinamurthy Karra - Initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ant.internal.ui.editor.templates;
12
13	import org.eclipse.ant.internal.ui.AntUIPlugin;
14	import org.eclipse.ant.internal.ui.editor.AntEditor;
15	import org.eclipse.ant.internal.ui.editor.formatter.FormattingPreferences;
16	import org.eclipse.ant.internal.ui.editor.formatter.XmlFormatter;
17	import org.eclipse.ant.internal.ui.editor.text.AntDocumentSetupParticipant;
18	import org.eclipse.ant.internal.ui.preferences.AntEditorPreferenceConstants;
19	import org.eclipse.jface.resource.JFaceResources;
20	import org.eclipse.jface.text.Document;
21	import org.eclipse.jface.text.IDocument;
22	import org.eclipse.jface.text.IRegion;
23	import org.eclipse.jface.text.ITextSelection;
24	import org.eclipse.jface.text.Position;
25	import org.eclipse.jface.text.Region;
26	import org.eclipse.jface.text.source.ISourceViewer;
27	import org.eclipse.jface.text.source.SourceViewer;
28	import org.eclipse.jface.text.source.SourceViewerConfiguration;
29	import org.eclipse.jface.text.templates.ContextTypeRegistry;
30	import org.eclipse.jface.text.templates.Template;
31	import org.eclipse.jface.text.templates.TemplateContextType;
32	import org.eclipse.swt.SWT;
33	import org.eclipse.swt.graphics.Font;
34	import org.eclipse.swt.graphics.Point;
35	import org.eclipse.swt.widgets.Composite;
36	import org.eclipse.ui.texteditor.templates.TemplatesPage;
37	import org.eclipse.ui.views.templates.ITemplatesPage;
38
39	/**
40	* An implementation of TemplatesPage for AntEditor
41	*
42	* @see TemplatesPage
43	* @since 3.4
44	*/
45	public class AntTemplatesPage extends TemplatesPage implements ITemplatesPage {
46
47	private static final ContextTypeRegistry CONTEXT_TYPE_REGISTRY = AntTemplateAccess
48	.getDefault().getContextTypeRegistry();
49	private FormattingPreferences fFormattingPreferences = new FormattingPreferences();
50	private final AntEditor fEditor;
51	private String fCurrentId;
52
53	/**
54	* Constructor
55	*
56	* @param editor
57	*/
58	public AntTemplatesPage(AntEditor editor) {
59	super(AntTemplateAccess.getDefault().getTemplateStore(),
60	AntUIPlugin.getDefault().getPreferenceStore(), CONTEXT_TYPE_REGISTRY);
61	fEditor = editor;
62	cursorPositionChanged();
63	setupEditorDropTarget(fEditor.getSite(), fEditor.getViewer()
64	.getTextWidget());
65	}
66
67	/*
68	* (non-Javadoc)
69	*
70	* @see org.eclipse.ui.texteditor.templates.TemplatePreferencePage#createViewer(org.eclipse.swt.widgets.Composite)
71	*/
72	protected SourceViewer createViewer(Composite parent) {
73	SourceViewer viewer = new SourceViewer(parent, null, SWT.BORDER
74	\| SWT.V_SCROLL \| SWT.H_SCROLL);
75
76	SourceViewerConfiguration configuration = new AntTemplateViewerConfiguration();
77	IDocument document = new Document();
78	new AntDocumentSetupParticipant().setup(document);
79	viewer.configure(configuration);
80	viewer.setDocument(document);
81	viewer.setEditable(false);
82	Font font = JFaceResources.getFont(JFaceResources.TEXT_FONT);
83	viewer.getTextWidget().setFont(font);
84
85	return viewer;
86	}
87
88	/*
89	* (non-Javadoc)
90	*
91	* @see org.eclipse.ui.texteditor.templates.TemplatePreferencePage#getFormatterPreferenceKey()
92	*/
93	protected String getFormatterPreferenceKey() {
94	return AntEditorPreferenceConstants.TEMPLATES_USE_CODEFORMATTER;
95	}
96
97	/*
98	* @see org.eclipse.ui.texteditor.templates.TemplatePreferencePage#updateViewerInput()
99	*/
100	protected void updateViewerInput(Template template) {
101	SourceViewer viewer = getViewer();
102
103	if (AntUIPlugin.getDefault().getPreferenceStore().getBoolean(
104	getFormatterPreferenceKey())) {
105	String formatted = XmlFormatter.format(template.getPattern(),
106	fFormattingPreferences);
107	viewer.getDocument().set(formatted);
108	} else {
109	viewer.getDocument().set(template.getPattern());
110	}
111	}
112
113	/*
114	* (non-Javadoc)
115	*
116	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#getPreferencePageId()
117	*/
118	protected String getPreferencePageId() {
119	return "org.eclipse.ant.ui.TemplatesPreferencePage"; //$NON-NLS-1$
120	}
121
122	/*
123	* (non-Javadoc)
124	*
125	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#insertTemplate(org.eclipse.jface.text.templates.Template)
126	*/
127	public void insertTemplate(Template template) {
128	if (!fEditor.validateEditorInputState())
129	return ;
130	IRegion region;
131	TemplateContextType type = CONTEXT_TYPE_REGISTRY
132	.getContextType(template.getContextTypeId());
133	if (type == null)
134	return;
135	ISourceViewer contextViewer = fEditor.getViewer();
136	ITextSelection textSelection = (ITextSelection) contextViewer
137	.getSelectionProvider().getSelection();
138	region = new Region(textSelection.getOffset(), textSelection
139	.getLength());
140	Point selection = contextViewer.getSelectedRange();
141	Position position;
142	if (selection.y > 0) {
143	position = new Position(selection.x, selection.y);
144	} else {
145	position = new Position(region.getOffset(), region.getLength());
146	}
147
148	IDocument document = contextViewer.getDocument();
149	AntContext context = new AntContext(type, document, fEditor
150	.getAntModel(), position);
151	context.setVariable("selection", textSelection.getText()); //$NON-NLS-1$
152	AntTemplateProposal proposal = new AntTemplateProposal(template,
153	context, region, null, 100);
154	fEditor.getSite().getPage().activate(fEditor);
155	proposal.apply(fEditor.getViewer(), ' ', 0, region.getOffset());
156	}
157
158	/**
159	* Invoked by the editor whenever the caret position is updated
160	*/
161	public void cursorPositionChanged() {
162	String id= getContextId();
163	if (id.equals(fCurrentId))
164	return;
165	fCurrentId = id;
166	if (fCurrentId.equals(BuildFileContextType.BUILDFILE_CONTEXT_TYPE))
167	contextTypeChanged(new String[] { BuildFileContextType.BUILDFILE_CONTEXT_TYPE });
168	else
169	contextTypeChanged(new String[] {
170	TargetContextType.TARGET_CONTEXT_TYPE,
171	TaskContextType.TASK_CONTEXT_TYPE });
172	}
173
174	/**
175	* Get the contextid for the editor
176	*
177	* @return contextId
178	*/
179	private String getContextId() {
180	if (fEditor.getDocumentProvider().getDocument(fEditor.getEditorInput())
181	.getLength() == 0)
182	return BuildFileContextType.BUILDFILE_CONTEXT_TYPE;
183	return TargetContextType.TARGET_CONTEXT_TYPE;
184	}
185
186	/* (non-Javadoc)
187	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#isValidTempalteForPosition(org.eclipse.jface.text.templates.Template, int, int)
188	*/
189	protected boolean isValidTemplateForPosition(Template template, int x, int y) {
190	return getContextId().equals(template.getContextTypeId());
191	}
192
193	/* (non-Javadoc)
194	* @see org.eclipse.ui.texteditor.templates.TemplatesPage#isEditorModifiable()
195	*/
196	protected boolean isEditorModifiable() {
197	return fEditor.isEditorInputModifiable();
198	}
199	}