Attachment #22282 for bug #71271

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 8-13 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Export-Package: org.eclipse.wst.html.internal.validation,	9	Export-Package: org.eclipse.wst.html.internal.validation,
10	org.eclipse.wst.html.ui.internal,	10	org.eclipse.wst.html.ui.internal,
		11	org.eclipse.wst.html.ui.internal.autoedit,
11	org.eclipse.wst.html.ui.internal.contentassist,	12	org.eclipse.wst.html.ui.internal.contentassist,
12	org.eclipse.wst.html.ui.internal.contentoutline,	13	org.eclipse.wst.html.ui.internal.contentoutline,
13	org.eclipse.wst.html.ui.internal.contentproperties.ui,	14	org.eclipse.wst.html.ui.internal.contentproperties.ui,





import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.eclipse.core.runtime.Preferences;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.text.JavaSourceViewerConfiguration;
import org.eclipse.jdt.ui.text.JavaTextTools;

import org.eclipse.wst.css.core.internal.provisional.text.ICSSPartitionTypes;
import org.eclipse.wst.css.ui.internal.contentassist.CSSContentAssistProcessor;
import org.eclipse.wst.css.ui.internal.style.LineStyleProviderForEmbeddedCSS;
import org.eclipse.wst.html.core.internal.HTMLCorePlugin;
import org.eclipse.wst.html.core.internal.format.HTMLFormatProcessorImpl;
import org.eclipse.wst.html.core.internal.preferences.HTMLCorePreferenceNames;
import org.eclipse.wst.html.core.internal.provisional.text.IHTMLPartitionTypes;
import org.eclipse.wst.html.core.internal.text.StructuredTextPartitionerForHTML;
import org.eclipse.wst.html.ui.internal.contentassist.HTMLContentAssistProcessor;

	InformationPresenter fInformationPresenter = null;

	private JavaSourceViewerConfiguration fJavaSourceViewerConfiguration;

	public StructuredTextViewerConfigurationHTML() {
		super();
	}

	public StructuredTextViewerConfigurationHTML(IPreferenceStore store) {
		super(store);
	}


	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer,
	 *      java.lang.String)
	 */
	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
		List allStrategies = new ArrayList(0);

		IAutoEditStrategy[] superStrategies = super.getAutoEditStrategies(sourceViewer, contentType);
		for (int i = 0; i < superStrategies.length; i++) {
			allStrategies.add(superStrategies[i]);
		}

		if (contentType == IHTMLPartitionTypes.HTML_DEFAULT || contentType == IHTMLPartitionTypes.HTML_DECLARATION) {
			allStrategies.add(new StructuredAutoEditStrategyXML());
		}

			fInformationPresenter.setInformationProvider(javascriptInformationProvider, IHTMLPartitionTypes.SCRIPT);

			fInformationPresenter.setSizeConstraints(60, 10, true, true);
			fInformationPresenter.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));
		}

		return fInformationPresenter;

					if (contentTypeId != null)
						fReconciler.setValidatorStrategy(createValidatorStrategy(contentTypeId));
				}
			} finally {
			finally {
				if (sModel != null)
					sModel.releaseFromRead();
			}

			if (hoverDescs[i].isEnabled() && EditorUtility.computeStateMask(hoverDescs[i].getModifierString()) == stateMask) {
				String hoverType = hoverDescs[i].getId();
				if (TextHoverManager.COMBINATION_HOVER.equalsIgnoreCase(hoverType)) {
					// check if script or html is needed
					if (contentType == IHTMLPartitionTypes.SCRIPT) {
						hover = new JavaScriptBestMatchHoverProcessor();
					} else if (contentType == IHTMLPartitionTypes.HTML_DEFAULT) {
					else {
						hover = new HTMLBestMatchHoverProcessor();
					}
				} else if (TextHoverManager.PROBLEM_HOVER.equalsIgnoreCase(hoverType)) {
				else if (TextHoverManager.PROBLEM_HOVER.equalsIgnoreCase(hoverType)) {
					hover = new ProblemAnnotationHoverProcessor();
				} else if (TextHoverManager.ANNOTATION_HOVER.equalsIgnoreCase(hoverType)) {
				else if (TextHoverManager.ANNOTATION_HOVER.equalsIgnoreCase(hoverType)) {
					hover = new AnnotationHoverProcessor();
				} else if (TextHoverManager.DOCUMENTATION_HOVER.equalsIgnoreCase(hoverType)) {
					// check if script or html is needed
					if (contentType == IHTMLPartitionTypes.SCRIPT) {
					if (contentType.equals(IHTMLPartitionTypes.SCRIPT)) {
						hover = new JavaScriptTagInfoHoverProcessor();
					} else if (contentType == IHTMLPartitionTypes.HTML_DEFAULT) {
					else {
						hover = new HTMLTagInfoHoverProcessor();
					}
				}

		if (fInformationPresenter != null)
			fInformationPresenter.uninstall();
	}

	public String[] getIndentPrefixes(ISourceViewer sourceViewer, String contentType) {
		Vector vector = new Vector();

		// prefix[0] is either '\t' or ' ' x tabWidth, depending on preference
		Preferences preferences = HTMLCorePlugin.getDefault().getPluginPreferences();
		int indentationWidth = preferences.getInt(HTMLCorePreferenceNames.INDENTATION_SIZE);
		String indentCharPref = preferences.getString(HTMLCorePreferenceNames.INDENTATION_CHAR);
		boolean useSpaces = HTMLCorePreferenceNames.SPACE.equals(indentCharPref);

		for (int i = 0; i <= indentationWidth; i++) {
			StringBuffer prefix = new StringBuffer();
			boolean appendTab = false;

			if (useSpaces) {
				for (int j = 0; j + i < indentationWidth; j++)
					prefix.append(' ');

				if (i != 0)
					appendTab = true;
			} else {
				for (int j = 0; j < i; j++)
					prefix.append(' ');

				if (i != indentationWidth)
					appendTab = true;
			}

			if (appendTab) {
				prefix.append('\t');
				vector.add(prefix.toString());
				// remove the tab so that indentation - tab is also an indent
				// prefix
				prefix.deleteCharAt(prefix.length() - 1);
			}
			vector.add(prefix.toString());
		}

		vector.add(""); //$NON-NLS-1$

		return (String[]) vector.toArray(new String[vector.size()]);
	}
}




/*******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.html.ui.internal.autoedit;

import org.eclipse.core.runtime.Preferences;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DocumentCommand;
import org.eclipse.jface.text.IAutoEditStrategy;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.ITextEditorExtension3;
import org.eclipse.wst.html.core.internal.HTMLCorePlugin;
import org.eclipse.wst.html.core.internal.preferences.HTMLCorePreferenceNames;
import org.eclipse.wst.html.ui.internal.Logger;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.ui.internal.StructuredDocumentCommand;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.w3c.dom.Node;

public class StructuredAutoEditStrategyHTML implements IAutoEditStrategy {
	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
		StructuredDocumentCommand structuredDocumentCommand = (StructuredDocumentCommand) command;
		Object textEditor = getActiveTextEditor();
		if (!(textEditor instanceof ITextEditorExtension3 && ((ITextEditorExtension3) textEditor).getInsertMode() == ITextEditorExtension3.SMART_INSERT))
			return;

		IStructuredModel model = null;
		try {
			model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
			if (model != null) {
				if (structuredDocumentCommand.text != null) {
					smartInsertForComment(structuredDocumentCommand, document, model);
					smartInsertForEndTag(structuredDocumentCommand, document, model);
				}
			}
		} finally {
			if (model != null)
				model.releaseFromRead();
		}

		// spaces for tab character
		if (command.text != null && command.text.length() > 0 && command.text.charAt(0) == '\t')
			smartInsertForTab(command, document);
	}

	private boolean isCommentNode(IDOMNode node) {
		return (node != null && node instanceof IDOMElement && ((IDOMElement) node).isCommentTag());
	}

	private boolean isDocumentNode(IDOMNode node) {
		return (node != null && node.getNodeType() == Node.DOCUMENT_NODE);
	}

	private void smartInsertForComment(StructuredDocumentCommand structuredDocumentCommand, IDocument document, IStructuredModel model) {
		try {
			if (structuredDocumentCommand.text.equals("-") && document.getLength() >= 3 && document.get(structuredDocumentCommand.offset - 3, 3).equals("<!-")) { //$NON-NLS-1$ //$NON-NLS-2$
				structuredDocumentCommand.text += " "; //$NON-NLS-1$
				structuredDocumentCommand.doit = false;
				structuredDocumentCommand.addCommand(structuredDocumentCommand.offset, 0, " -->", null); //$NON-NLS-1$
			}
		} catch (BadLocationException e) {
			Logger.logException(e);
		}

	}

	private void smartInsertForEndTag(StructuredDocumentCommand structuredDocumentCommand, IDocument document, IStructuredModel model) {
		try {
			if (structuredDocumentCommand.text.equals("/") && document.getLength() >= 1 && document.get(structuredDocumentCommand.offset - 1, 1).equals("<")) { //$NON-NLS-1$ //$NON-NLS-2$
				IDOMNode parentNode = (IDOMNode) ((IDOMNode) model.getIndexedRegion(structuredDocumentCommand.offset - 1)).getParentNode();
				if (isCommentNode(parentNode)) {
					// loop and find non comment node parent
					while (parentNode != null && isCommentNode(parentNode)) {
						parentNode = (IDOMNode) parentNode.getParentNode();
					}
				}

				if (!isDocumentNode(parentNode)) {
					IStructuredDocumentRegion endTagStructuredDocumentRegion = parentNode.getEndStructuredDocumentRegion();
					if (endTagStructuredDocumentRegion == null) {
						structuredDocumentCommand.text += parentNode.getNodeName();
						structuredDocumentCommand.text += ">"; //$NON-NLS-1$
					}
				}
			}
		} catch (BadLocationException e) {
			Logger.logException(e);
		}
	}

	/**
	 * Insert spaces for tabs
	 * 
	 * @param command
	 */
	private void smartInsertForTab(DocumentCommand command, IDocument document) {
		// tab key was pressed. now check preferences to see if need to insert
		// spaces instead of tab
		Preferences preferences = HTMLCorePlugin.getDefault().getPluginPreferences();
		if (HTMLCorePreferenceNames.SPACE.equals(preferences.getString(HTMLCorePreferenceNames.INDENTATION_CHAR))) {
			int indentationWidth = preferences.getInt(HTMLCorePreferenceNames.INDENTATION_SIZE);

			StringBuffer indent = new StringBuffer();
			if (indentationWidth != 0) {
				int indentSize = indentationWidth;
				try {
					IRegion firstLine = document.getLineInformationOfOffset(command.offset);
					int offsetInLine = command.offset - firstLine.getOffset();
					int remainder = offsetInLine % indentationWidth;

					indentSize = indentationWidth - remainder;
				} catch (BadLocationException e) {
					Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
				}

				for (int i = 0; i < indentSize; i++)
					indent.append(' ');
			}

			// replace \t characters with spaces
			command.text = indent.toString();
		}
	}

	/**
	 * Return the active text editor if possible, otherwise the active editor
	 * part.
	 * 
	 * @return
	 */
	private Object getActiveTextEditor() {
		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		if (window != null) {
			IWorkbenchPage page = window.getActivePage();
			if (page != null) {
				IEditorPart editor = page.getActiveEditor();
				if (editor != null) {
					if (editor instanceof ITextEditor)
						return editor;
					ITextEditor textEditor = (ITextEditor) editor.getAdapter(ITextEditor.class);
					if (textEditor != null)
						return textEditor;
					return editor;
				}
			}
		}
		return null;
	}
}

Return to bug 71271

Lines 12-18 Link Here

(-)src/org/eclipse/wst/html/ui/internal/provisional/StructuredTextViewerConfigurationHTML.java (-24 / +68 lines)
12		12
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.List;	14	import java.util.List;
		15	import java.util.Vector;
15		16
		17	import org.eclipse.core.runtime.Preferences;
16	import org.eclipse.jdt.ui.PreferenceConstants;	18	import org.eclipse.jdt.ui.PreferenceConstants;
17	import org.eclipse.jdt.ui.text.JavaSourceViewerConfiguration;	19	import org.eclipse.jdt.ui.text.JavaSourceViewerConfiguration;
18	import org.eclipse.jdt.ui.text.JavaTextTools;	20	import org.eclipse.jdt.ui.text.JavaTextTools;
Lines 38-44 Link Here
38	import org.eclipse.wst.css.core.internal.provisional.text.ICSSPartitionTypes;	40	import org.eclipse.wst.css.core.internal.provisional.text.ICSSPartitionTypes;
39	import org.eclipse.wst.css.ui.internal.contentassist.CSSContentAssistProcessor;	41	import org.eclipse.wst.css.ui.internal.contentassist.CSSContentAssistProcessor;
40	import org.eclipse.wst.css.ui.internal.style.LineStyleProviderForEmbeddedCSS;	42	import org.eclipse.wst.css.ui.internal.style.LineStyleProviderForEmbeddedCSS;
		43	import org.eclipse.wst.html.core.internal.HTMLCorePlugin;
41	import org.eclipse.wst.html.core.internal.format.HTMLFormatProcessorImpl;	44	import org.eclipse.wst.html.core.internal.format.HTMLFormatProcessorImpl;
		45	import org.eclipse.wst.html.core.internal.preferences.HTMLCorePreferenceNames;
42	import org.eclipse.wst.html.core.internal.provisional.text.IHTMLPartitionTypes;	46	import org.eclipse.wst.html.core.internal.provisional.text.IHTMLPartitionTypes;
43	import org.eclipse.wst.html.core.internal.text.StructuredTextPartitionerForHTML;	47	import org.eclipse.wst.html.core.internal.text.StructuredTextPartitionerForHTML;
44	import org.eclipse.wst.html.ui.internal.contentassist.HTMLContentAssistProcessor;	48	import org.eclipse.wst.html.ui.internal.contentassist.HTMLContentAssistProcessor;
Lines 79-105 Link Here
79	InformationPresenter fInformationPresenter = null;	83	InformationPresenter fInformationPresenter = null;
80		84
81	private JavaSourceViewerConfiguration fJavaSourceViewerConfiguration;	85	private JavaSourceViewerConfiguration fJavaSourceViewerConfiguration;
82		86
83	public StructuredTextViewerConfigurationHTML() {	87	public StructuredTextViewerConfigurationHTML() {
84	super();	88	super();
85	}	89	}
86		90
87	public StructuredTextViewerConfigurationHTML(IPreferenceStore store) {	91	public StructuredTextViewerConfigurationHTML(IPreferenceStore store) {
88	super(store);	92	super(store);
89	}	93	}
90		94
91		95
92	/* (non-Javadoc)	96	/*
93	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer, java.lang.String)	97	* (non-Javadoc)
		98	*
		99	* @see org.eclipse.jface.text.source.SourceViewerConfiguration#getAutoEditStrategies(org.eclipse.jface.text.source.ISourceViewer,
		100	* java.lang.String)
94	*/	101	*/
95	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {	102	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
96	List allStrategies = new ArrayList(0);	103	List allStrategies = new ArrayList(0);
97		104
98	IAutoEditStrategy[] superStrategies = super.getAutoEditStrategies(sourceViewer, contentType);	105	IAutoEditStrategy[] superStrategies = super.getAutoEditStrategies(sourceViewer, contentType);
99	for (int i = 0; i < superStrategies.length; i++) {	106	for (int i = 0; i < superStrategies.length; i++) {
100	allStrategies.add(superStrategies[i]);	107	allStrategies.add(superStrategies[i]);
101	}	108	}
102		109
103	if (contentType == IHTMLPartitionTypes.HTML_DEFAULT \|\| contentType == IHTMLPartitionTypes.HTML_DECLARATION) {	110	if (contentType == IHTMLPartitionTypes.HTML_DEFAULT \|\| contentType == IHTMLPartitionTypes.HTML_DECLARATION) {
104	allStrategies.add(new StructuredAutoEditStrategyXML());	111	allStrategies.add(new StructuredAutoEditStrategyXML());
105	}	112	}
Lines 248-253 Link Here
248	fInformationPresenter.setInformationProvider(javascriptInformationProvider, IHTMLPartitionTypes.SCRIPT);	255	fInformationPresenter.setInformationProvider(javascriptInformationProvider, IHTMLPartitionTypes.SCRIPT);
249		256
250	fInformationPresenter.setSizeConstraints(60, 10, true, true);	257	fInformationPresenter.setSizeConstraints(60, 10, true, true);
		258	fInformationPresenter.setDocumentPartitioning(getConfiguredDocumentPartitioning(sourceViewer));
251	}	259	}
252		260
253	return fInformationPresenter;	261	return fInformationPresenter;
Lines 302-309 Link Here
302	if (contentTypeId != null)	310	if (contentTypeId != null)
303	fReconciler.setValidatorStrategy(createValidatorStrategy(contentTypeId));	311	fReconciler.setValidatorStrategy(createValidatorStrategy(contentTypeId));
304	}	312	}
305	}	313	} finally {
306	finally {
307	if (sModel != null)	314	if (sModel != null)
308	sModel.releaseFromRead();	315	sModel.releaseFromRead();
309	}	316	}
Lines 319-344 Link Here
319	if (hoverDescs[i].isEnabled() && EditorUtility.computeStateMask(hoverDescs[i].getModifierString()) == stateMask) {	326	if (hoverDescs[i].isEnabled() && EditorUtility.computeStateMask(hoverDescs[i].getModifierString()) == stateMask) {
320	String hoverType = hoverDescs[i].getId();	327	String hoverType = hoverDescs[i].getId();
321	if (TextHoverManager.COMBINATION_HOVER.equalsIgnoreCase(hoverType)) {	328	if (TextHoverManager.COMBINATION_HOVER.equalsIgnoreCase(hoverType)) {
322	// treat specially if it's JavaScript, HTML otherwise	329	// check if script or html is needed
323	if (contentType.equals(IHTMLPartitionTypes.SCRIPT)) {	330	if (contentType == IHTMLPartitionTypes.SCRIPT) {
324	hover = new JavaScriptBestMatchHoverProcessor();	331	hover = new JavaScriptBestMatchHoverProcessor();
325	}	332	} else if (contentType == IHTMLPartitionTypes.HTML_DEFAULT) {
326	else {
327	hover = new HTMLBestMatchHoverProcessor();	333	hover = new HTMLBestMatchHoverProcessor();
328	}	334	}
329	}	335	} else if (TextHoverManager.PROBLEM_HOVER.equalsIgnoreCase(hoverType)) {
330	else if (TextHoverManager.PROBLEM_HOVER.equalsIgnoreCase(hoverType)) {
331	hover = new ProblemAnnotationHoverProcessor();	336	hover = new ProblemAnnotationHoverProcessor();
332	}	337	} else if (TextHoverManager.ANNOTATION_HOVER.equalsIgnoreCase(hoverType)) {
333	else if (TextHoverManager.ANNOTATION_HOVER.equalsIgnoreCase(hoverType)) {
334	hover = new AnnotationHoverProcessor();	338	hover = new AnnotationHoverProcessor();
335	}	339	} else if (TextHoverManager.DOCUMENTATION_HOVER.equalsIgnoreCase(hoverType)) {
336	else if (TextHoverManager.DOCUMENTATION_HOVER.equalsIgnoreCase(hoverType)) {	340	// check if script or html is needed
337	// treat specially if it's JavaScript, HTML otherwise	341	if (contentType == IHTMLPartitionTypes.SCRIPT) {
338	if (contentType.equals(IHTMLPartitionTypes.SCRIPT)) {
339	hover = new JavaScriptTagInfoHoverProcessor();	342	hover = new JavaScriptTagInfoHoverProcessor();
340	}	343	} else if (contentType == IHTMLPartitionTypes.HTML_DEFAULT) {
341	else {
342	hover = new HTMLTagInfoHoverProcessor();	344	hover = new HTMLTagInfoHoverProcessor();
343	}	345	}
344	}	346	}
Lines 358-361 Link Here
358	if (fInformationPresenter != null)	360	if (fInformationPresenter != null)
359	fInformationPresenter.uninstall();	361	fInformationPresenter.uninstall();
360	}	362	}
		363
		364	public String[] getIndentPrefixes(ISourceViewer sourceViewer, String contentType) {
		365	Vector vector = new Vector();
		366
		367	// prefix[0] is either '\t' or ' ' x tabWidth, depending on preference
		368	Preferences preferences = HTMLCorePlugin.getDefault().getPluginPreferences();
		369	int indentationWidth = preferences.getInt(HTMLCorePreferenceNames.INDENTATION_SIZE);
		370	String indentCharPref = preferences.getString(HTMLCorePreferenceNames.INDENTATION_CHAR);
		371	boolean useSpaces = HTMLCorePreferenceNames.SPACE.equals(indentCharPref);
		372
		373	for (int i = 0; i <= indentationWidth; i++) {
		374	StringBuffer prefix = new StringBuffer();
		375	boolean appendTab = false;
		376
		377	if (useSpaces) {
		378	for (int j = 0; j + i < indentationWidth; j++)
		379	prefix.append(' ');
		380
		381	if (i != 0)
		382	appendTab = true;
		383	} else {
		384	for (int j = 0; j < i; j++)
		385	prefix.append(' ');
		386
		387	if (i != indentationWidth)
		388	appendTab = true;
		389	}
		390
		391	if (appendTab) {
		392	prefix.append('\t');
		393	vector.add(prefix.toString());
		394	// remove the tab so that indentation - tab is also an indent
		395	// prefix
		396	prefix.deleteCharAt(prefix.length() - 1);
		397	}
		398	vector.add(prefix.toString());
		399	}
		400
		401	vector.add(""); //$NON-NLS-1$
		402
		403	return (String[]) vector.toArray(new String[vector.size()]);
		404	}
361	}	405	}

Added Link Here

(-)src/org/eclipse/wst/html/ui/internal/autoedit/StructuredAutoEditStrategyHTML.java (+165 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.html.ui.internal.autoedit;
12
13	import org.eclipse.core.runtime.Preferences;
14	import org.eclipse.jface.text.BadLocationException;
15	import org.eclipse.jface.text.DocumentCommand;
16	import org.eclipse.jface.text.IAutoEditStrategy;
17	import org.eclipse.jface.text.IDocument;
18	import org.eclipse.jface.text.IRegion;
19	import org.eclipse.ui.IEditorPart;
20	import org.eclipse.ui.IWorkbenchPage;
21	import org.eclipse.ui.IWorkbenchWindow;
22	import org.eclipse.ui.PlatformUI;
23	import org.eclipse.ui.texteditor.ITextEditor;
24	import org.eclipse.ui.texteditor.ITextEditorExtension3;
25	import org.eclipse.wst.html.core.internal.HTMLCorePlugin;
26	import org.eclipse.wst.html.core.internal.preferences.HTMLCorePreferenceNames;
27	import org.eclipse.wst.html.ui.internal.Logger;
28	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
29	import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
30	import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
31	import org.eclipse.wst.sse.ui.internal.StructuredDocumentCommand;
32	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
33	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
34	import org.w3c.dom.Node;
35
36	public class StructuredAutoEditStrategyHTML implements IAutoEditStrategy {
37	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
38	StructuredDocumentCommand structuredDocumentCommand = (StructuredDocumentCommand) command;
39	Object textEditor = getActiveTextEditor();
40	if (!(textEditor instanceof ITextEditorExtension3 && ((ITextEditorExtension3) textEditor).getInsertMode() == ITextEditorExtension3.SMART_INSERT))
41	return;
42
43	IStructuredModel model = null;
44	try {
45	model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
46	if (model != null) {
47	if (structuredDocumentCommand.text != null) {
48	smartInsertForComment(structuredDocumentCommand, document, model);
49	smartInsertForEndTag(structuredDocumentCommand, document, model);
50	}
51	}
52	} finally {
53	if (model != null)
54	model.releaseFromRead();
55	}
56
57	// spaces for tab character
58	if (command.text != null && command.text.length() > 0 && command.text.charAt(0) == '\t')
59	smartInsertForTab(command, document);
60	}
61
62	private boolean isCommentNode(IDOMNode node) {
63	return (node != null && node instanceof IDOMElement && ((IDOMElement) node).isCommentTag());
64	}
65
66	private boolean isDocumentNode(IDOMNode node) {
67	return (node != null && node.getNodeType() == Node.DOCUMENT_NODE);
68	}
69
70	private void smartInsertForComment(StructuredDocumentCommand structuredDocumentCommand, IDocument document, IStructuredModel model) {
71	try {
72	if (structuredDocumentCommand.text.equals("-") && document.getLength() >= 3 && document.get(structuredDocumentCommand.offset - 3, 3).equals("<!-")) { //$NON-NLS-1$ //$NON-NLS-2$
73	structuredDocumentCommand.text += " "; //$NON-NLS-1$
74	structuredDocumentCommand.doit = false;
75	structuredDocumentCommand.addCommand(structuredDocumentCommand.offset, 0, " -->", null); //$NON-NLS-1$
76	}
77	} catch (BadLocationException e) {
78	Logger.logException(e);
79	}
80
81	}
82
83	private void smartInsertForEndTag(StructuredDocumentCommand structuredDocumentCommand, IDocument document, IStructuredModel model) {
84	try {
85	if (structuredDocumentCommand.text.equals("/") && document.getLength() >= 1 && document.get(structuredDocumentCommand.offset - 1, 1).equals("<")) { //$NON-NLS-1$ //$NON-NLS-2$
86	IDOMNode parentNode = (IDOMNode) ((IDOMNode) model.getIndexedRegion(structuredDocumentCommand.offset - 1)).getParentNode();
87	if (isCommentNode(parentNode)) {
88	// loop and find non comment node parent
89	while (parentNode != null && isCommentNode(parentNode)) {
90	parentNode = (IDOMNode) parentNode.getParentNode();
91	}
92	}
93
94	if (!isDocumentNode(parentNode)) {
95	IStructuredDocumentRegion endTagStructuredDocumentRegion = parentNode.getEndStructuredDocumentRegion();
96	if (endTagStructuredDocumentRegion == null) {
97	structuredDocumentCommand.text += parentNode.getNodeName();
98	structuredDocumentCommand.text += ">"; //$NON-NLS-1$
99	}
100	}
101	}
102	} catch (BadLocationException e) {
103	Logger.logException(e);
104	}
105	}
106
107	/**
108	* Insert spaces for tabs
109	*
110	* @param command
111	*/
112	private void smartInsertForTab(DocumentCommand command, IDocument document) {
113	// tab key was pressed. now check preferences to see if need to insert
114	// spaces instead of tab
115	Preferences preferences = HTMLCorePlugin.getDefault().getPluginPreferences();
116	if (HTMLCorePreferenceNames.SPACE.equals(preferences.getString(HTMLCorePreferenceNames.INDENTATION_CHAR))) {
117	int indentationWidth = preferences.getInt(HTMLCorePreferenceNames.INDENTATION_SIZE);
118
119	StringBuffer indent = new StringBuffer();
120	if (indentationWidth != 0) {
121	int indentSize = indentationWidth;
122	try {
123	IRegion firstLine = document.getLineInformationOfOffset(command.offset);
124	int offsetInLine = command.offset - firstLine.getOffset();
125	int remainder = offsetInLine % indentationWidth;
126
127	indentSize = indentationWidth - remainder;
128	} catch (BadLocationException e) {
129	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
130	}
131
132	for (int i = 0; i < indentSize; i++)
133	indent.append(' ');
134	}
135
136	// replace \t characters with spaces
137	command.text = indent.toString();
138	}
139	}
140
141	/**
142	* Return the active text editor if possible, otherwise the active editor
143	* part.
144	*
145	* @return
146	*/
147	private Object getActiveTextEditor() {
148	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
149	if (window != null) {
150	IWorkbenchPage page = window.getActivePage();
151	if (page != null) {
152	IEditorPart editor = page.getActiveEditor();
153	if (editor != null) {
154	if (editor instanceof ITextEditor)
155	return editor;
156	ITextEditor textEditor = (ITextEditor) editor.getAdapter(ITextEditor.class);
157	if (textEditor != null)
158	return textEditor;
159	return editor;
160	}
161	}
162	}
163	return null;
164	}
165	}