/*******************************************************************************
* Copyright (c) 2000, 2010, 2013 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
* Sergey Prigogin, Google
* Anton Leherbauer (Wind River Systems)
* Red Hat Inc. - modified for use in SystemTap
*******************************************************************************/
package org.eclipse.linuxtools.internal.systemtap.ui.ide.handlers;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.IRewriteTarget;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.linuxtools.internal.systemtap.ui.ide.IDEPlugin;
import org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.IndentUtil;
import org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.STPDefaultCodeFormatterConstants;
import org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.STPEditor;
import org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.STPHeuristicScanner;
import org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.STPIndenter;
import org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.STPPartitionScanner;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;
/**
* Indents a line or range of lines in a C document to its correct position. No
* complete AST must be present, the indentation is computed using heuristics.
* The algorithm used is fast for single lines, but does not store any
* information and therefore not so efficient for large line ranges.
*
* @see org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.STPHeuristicScanner
* @see org.eclipse.linuxtools.internal.systemtap.ui.ide.editors.stp.STPIndenter
*/
public class IndentHandler extends AbstractHandler {
/** The caret offset after an indent operation. */
private int fCaretOffset;
private class STPRunnable implements Runnable {
private ITextEditor editor;
public STPRunnable(ITextEditor editor) {
this.editor = editor;
}
public ITextEditor getTextEditor() {
return editor;
}
@Override
public void run() {
}
}
/**
* Whether this is the action invoked by TAB. When <code>true</code>,
* indentation behaves differently to accommodate normal TAB operation.
*/
private final boolean fIsTabAction = false;
@Override
public Object execute(ExecutionEvent event) { // Update has been called by
// the framework
if (!isEnabled())
return null;
ITextEditor editor = (ITextEditor) HandlerUtil.getActiveEditor(event);
if (editor == null || !editor.isEditable()) {
return null;
}
ITextSelection selection = getSelection(editor);
final IDocument document = getDocument(editor);
if (document != null) {
final int offset = selection.getOffset();
final int length = selection.getLength();
final Position end = new Position(offset + length);
final int firstLine, nLines;
fCaretOffset = -1;
try {
firstLine = document.getLineOfOffset(offset);
// check for marginal (zero-length) lines
int minusOne = length == 0 ? 0 : 1;
nLines = document.getLineOfOffset(offset + length - minusOne)
- firstLine + 1;
document.addPosition(end);
} catch (BadLocationException e) {
// will only happen on concurrent modification
IDEPlugin.log(new Status(IStatus.ERROR,
IDEPlugin.PLUGIN_ID, IStatus.OK, "", e)); //$NON-NLS-1$
return null;
}
Runnable runnable = new STPRunnable(editor) {
@Override
public void run() {
IRewriteTarget target = getTextEditor()
.getAdapter(IRewriteTarget.class);
if (target != null) {
target.beginCompoundChange();
}
try {
STPHeuristicScanner scanner = new STPHeuristicScanner(
document);
STPIndenter indenter = new STPIndenter(document,
scanner, getProject(getTextEditor()));
final boolean multiLine = nLines > 1;
boolean hasChanged = false;
for (int i = 0; i < nLines; i++) {
hasChanged |= indentLine(document, firstLine + i,
offset, indenter, scanner, multiLine);
}
// update caret position: move to new position when
// indenting just one line
// keep selection when indenting multiple
int newOffset, newLength;
if (!fIsTabAction && multiLine) {
newOffset = offset;
newLength = end.getOffset() - offset;
} else {
newOffset = fCaretOffset;
newLength = 0;
}
// always reset the selection if anything was replaced
// but not when we had a single line non-tab invocation
if (newOffset != -1
&& (hasChanged || newOffset != offset || newLength != length))
selectAndReveal(getTextEditor(), newOffset,
newLength);
} catch (BadLocationException e) {
// will only happen on concurrent modification
IDEPlugin.log(new Status(IStatus.ERROR, IDEPlugin
.PLUGIN_ID, IStatus.OK,
"ConcurrentModification in IndentAction", e)); //$NON-NLS-1$
} finally {
document.removePosition(end);
if (target != null) {
target.endCompoundChange();
}
}
}
};
if (nLines > 50) {
Display display = editor.getEditorSite().getWorkbenchWindow()
.getShell().getDisplay();
BusyIndicator.showWhile(display, runnable);
} else {
runnable.run();
}
}
return null;
}
/**
* Selects the given range on the editor.
*
* @param newOffset
* the selection offset
* @param newLength
* the selection range
*/
private void selectAndReveal(ITextEditor editor, int newOffset,
int newLength) {
Assert.isTrue(newOffset >= 0);
Assert.isTrue(newLength >= 0);
if (editor instanceof STPEditor) {
ISourceViewer viewer = ((STPEditor) editor).getMySourceViewer();
if (viewer != null) {
viewer.setSelectedRange(newOffset, newLength);
}
} else {
// this is too intrusive, but will never get called anyway
editor.selectAndReveal(newOffset, newLength);
}
}
/**
* Indents a single line using the heuristic scanner. Multiline comments are
* indented as specified by the <code>CCommentAutoIndentStrategy</code>.
*
* @param document
* the document
* @param line
* the line to be indented
* @param caret
* the caret position
* @param indenter
* the indenter
* @param scanner
* the heuristic scanner
* @param multiLine
* <code>true</code> if more than one line is being indented
* @return <code>true</code> if <code>document</code> was modified,
* <code>false</code> otherwise
* @throws BadLocationException
* if the document got changed concurrently
*/
private boolean indentLine(IDocument document,
int line, int caret, STPIndenter indenter,
STPHeuristicScanner scanner, boolean multiLine)
throws BadLocationException {
IRegion currentLine = document.getLineInformation(line);
int offset = currentLine.getOffset();
int wsStart = offset; // where we start searching for non-WS; after the
// "//" in single line comments
String indent = null;
if (offset < document.getLength()) {
ITypedRegion partition = TextUtilities.getPartition(document,
STPPartitionScanner.STP_PARTITIONING, offset, true);
ITypedRegion startingPartition = TextUtilities.getPartition(
document, STPPartitionScanner.STP_PARTITIONING, offset,
false);
String type = partition.getType();
if (type.equals(STPPartitionScanner.STP_MULTILINE_COMMENT)) {
indent = computeCommentIndent(document, line, scanner,
startingPartition);
} else if (startingPartition.getType().equals(
STPPartitionScanner.STP_CONDITIONAL)) {
indent = computePreprocessorIndent(document, line,
startingPartition);
} else if (startingPartition.getType().equals(
STPPartitionScanner.STP_STRING)
&& offset > startingPartition.getOffset()) {
// don't indent inside (raw-)string
return false;
} else if (!fIsTabAction
&& startingPartition.getOffset() == offset
&& startingPartition.getType().equals(
STPPartitionScanner.STP_COMMENT)) {
// line comment starting at position 0 -> indent inside
if (indentInsideLineComments()) {
int max = document.getLength() - offset;
int slashes = 2;
while (slashes < max - 1
&& document.get(offset + slashes, 2).equals("//")) //$NON-NLS-1$
slashes += 2;
wsStart = offset + slashes;
StringBuilder computed = indenter
.computeIndentation(offset);
if (computed == null)
computed = new StringBuilder(0);
int tabSize = getTabSize();
while (slashes > 0 && computed.length() > 0) {
char c = computed.charAt(0);
if (c == '\t') {
if (slashes > tabSize) {
slashes -= tabSize;
} else {
break;
}
} else if (c == ' ') {
slashes--;
} else {
break;
}
computed.deleteCharAt(0);
}
indent = document.get(offset, wsStart - offset) + computed;
}
}
}
// standard C code indentation
if (indent == null) {
StringBuilder computed = indenter.computeIndentation(offset);
if (computed != null) {
indent = computed.toString();
} else {
indent = ""; //$NON-NLS-1$
}
}
// change document:
// get current white space
int lineLength = currentLine.getLength();
int end = scanner.findNonWhitespaceForwardInAnyPartition(wsStart,
offset + lineLength);
if (end == STPHeuristicScanner.NOT_FOUND) {
// an empty line
end = offset + lineLength;
if (multiLine && !indentEmptyLines()) {
indent = ""; //$NON-NLS-1$
}
}
int length = end - offset;
String currentIndent = document.get(offset, length);
// set the caret offset so it can be used when setting the selection
if (caret >= offset && caret <= end) {
fCaretOffset = offset + indent.length();
} else {
fCaretOffset = -1;
}
// only change the document if it is a real change
if (!indent.equals(currentIndent)) {
document.replace(offset, length, indent);
return true;
}
return false;
}
/**
* Computes and returns the indentation for a block comment line.
*
* @param document
* the document
* @param line
* the line in document
* @param scanner
* the scanner
* @param partition
* the comment partition
* @return the indent, or <code>null</code> if not computable
* @throws BadLocationException
*/
private String computeCommentIndent(IDocument document, int line,
STPHeuristicScanner scanner, ITypedRegion partition)
throws BadLocationException {
return IndentUtil.computeCommentIndent(document, line, scanner,
partition);
}
/**
* Computes and returns the indentation for a preprocessor line.
*
* @param document
* the document
* @param line
* the line in document
* @param partition
* the comment partition
* @return the indent, or <code>null</code> if not computable
* @throws BadLocationException
*/
private String computePreprocessorIndent(IDocument document, int line,
ITypedRegion partition) throws BadLocationException {
return IndentUtil.computePreprocessorIndent(document, line, partition);
}
/**
* Returns the tab size used by the editor, which is deduced from the
* formatter preferences.
*
* @return the tab size as defined in the current formatter preferences
*/
private int getTabSize() {
return getCoreFormatterOption(4);
}
/**
* Returns <code>true</code> if empty lines should be indented,
* <code>false</code> otherwise.
*
* @return <code>true</code> if empty lines should be indented,
* <code>false</code> otherwise
*/
private boolean indentEmptyLines() {
return STPDefaultCodeFormatterConstants.TRUE
.equals(getCoreFormatterOption());
}
/**
* Returns <code>true</code> if line comments at column 0 should be indented
* inside, <code>false</code> otherwise.
*
* @return <code>true</code> if line comments at column 0 should be indented
* inside, <code>false</code> otherwise.
*/
private boolean indentInsideLineComments() {
return STPDefaultCodeFormatterConstants.TRUE
.equals(getCoreFormatterOption());
}
/**
* Returns the possibly project-specific core preference defined under
* <code>key</code>.
*
* @param key
* the key of the preference
* @return the value of the preference
*/
private String getCoreFormatterOption() {
return "false"; //$NON-NLS-1$
}
/**
* Returns the possibly project-specific core preference defined under
* <code>key</code>, or <code>def</code> if the value is not a integer.
*
* @param def
* the default value
* @return the value of the preference
*/
private int getCoreFormatterOption(int def) {
try {
return Integer.parseInt(getCoreFormatterOption());
} catch (NumberFormatException e) {
return def;
}
}
/**
* Returns the <code>IProject</code> of the current editor input, or
* <code>null</code> if it cannot be found.
*
* @return the <code>IProject</code> of the current editor input, or
* <code>null</code> if it cannot be found
*/
private IProject getProject(ITextEditor editor) {
if (editor == null)
return null;
IEditorInput input = editor.getEditorInput();
if (input instanceof IFileEditorInput)
return ((IFileEditorInput) input).getFile().getProject();
return null;
}
/**
* Returns the editor's selection provider.
*
* @return the editor's selection provider or <code>null</code>
*/
private ISelectionProvider getSelectionProvider(ITextEditor editor) {
if (editor != null) {
return editor.getSelectionProvider();
}
return null;
}
/**
* Returns the document currently displayed in the editor, or
* <code>null</code> if none can be obtained.
*
* @return the current document or <code>null</code>
*/
private IDocument getDocument(ITextEditor editor) {
if (editor != null) {
IDocumentProvider provider = editor.getDocumentProvider();
IEditorInput input = editor.getEditorInput();
if (provider != null && input != null)
return provider.getDocument(input);
}
return null;
}
/**
* Returns the selection on the editor or an invalid selection if none can
* be obtained. Returns never <code>null</code>.
*
* @return the current selection, never <code>null</code>
*/
private ITextSelection getSelection(ITextEditor editor) {
ISelectionProvider provider = getSelectionProvider(editor);
if (provider != null) {
ISelection selection = provider.getSelection();
if (selection instanceof ITextSelection)
return (ITextSelection) selection;
}
// null object
return TextSelection.emptySelection();
}
}