net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/ui/actions/IndentAction.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.ui.actions;
  12
  13 import java.util.ResourceBundle;
  14
  15 import net.sourceforge.phpdt.core.JavaCore;
  16 import net.sourceforge.phpdt.core.formatter.DefaultCodeFormatterConstants;
  17 import net.sourceforge.phpdt.internal.ui.text.IPHPPartitions;
  18 import net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner;
  19 import net.sourceforge.phpdt.internal.ui.text.JavaIndenter;
  20 import net.sourceforge.phpdt.internal.ui.text.SmartBackspaceManager;
  21 import net.sourceforge.phpdt.internal.ui.text.SmartBackspaceManager.UndoSpec;
  22 import net.sourceforge.phpdt.internal.ui.text.phpdoc.JavaDocAutoIndentStrategy;
  23 import net.sourceforge.phpdt.ui.PreferenceConstants;
  24 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  25 import net.sourceforge.phpeclipse.phpeditor.PHPEditor;
  26
  27 import org.eclipse.core.runtime.IStatus;
  28 import org.eclipse.core.runtime.Status;
  29 import org.eclipse.jface.text.Assert;
  30 import org.eclipse.jface.text.BadLocationException;
  31 import org.eclipse.jface.text.DocumentCommand;
  32 import org.eclipse.jface.text.IDocument;
  33 import org.eclipse.jface.text.IRegion;
  34 import org.eclipse.jface.text.IRewriteTarget;
  35 import org.eclipse.jface.text.ITextSelection;
  36 import org.eclipse.jface.text.ITypedRegion;
  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.viewers.ISelection;
  43 import org.eclipse.jface.viewers.ISelectionProvider;
  44 import org.eclipse.swt.custom.BusyIndicator;
  45 import org.eclipse.swt.widgets.Display;
  46 import org.eclipse.text.edits.MalformedTreeException;
  47 import org.eclipse.text.edits.ReplaceEdit;
  48 import org.eclipse.text.edits.TextEdit;
  49 import org.eclipse.ui.IEditorInput;
  50 import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
  51 import org.eclipse.ui.texteditor.IDocumentProvider;
  52 import org.eclipse.ui.texteditor.ITextEditor;
  53 import org.eclipse.ui.texteditor.ITextEditorExtension3;
  54 import org.eclipse.ui.texteditor.TextEditorAction;
  55
  56
  57 /**
  58  * Indents a line or range of lines in a Java document to its correct position. No complete
  59  * AST must be present, the indentation is computed using heuristics. The algorith used is fast for
  60  * single lines, but does not store any information and therefore not so efficient for large line
  61  * ranges.
  62  *
  63  * @see net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner
  64  * @see net.sourceforge.phpdt.internal.ui.text.JavaIndenter
  65  * @since 3.0
  66  */
  67 public class IndentAction extends TextEditorAction {
  68
  69         /** The caret offset after an indent operation. */
  70         private int fCaretOffset;
  71
  72         /**
  73          * Whether this is the action invoked by TAB. When <code>true</code>, indentation behaves
  74          * differently to accomodate normal TAB operation.
  75          */
  76         private final boolean fIsTabAction;
  77
  78         /**
  79          * Creates a new instance.
  80          *
  81          * @param bundle the resource bundle
  82          * @param prefix the prefix to use for keys in <code>bundle</code>
  83          * @param editor the text editor
  84          * @param isTabAction whether the action should insert tabs if over the indentation
  85          */
  86         public IndentAction(ResourceBundle bundle, String prefix, ITextEditor editor, boolean isTabAction) {
  87                 super(bundle, prefix, editor);
  88                 fIsTabAction= isTabAction;
  89         }
  90
  91         /*
  92          * @see org.eclipse.jface.action.Action#run()
  93          */
  94         public void run() {
  95                 // update has been called by the framework
  96                 if (!isEnabled() || !validateEditorInputState())
  97                         return;
  98
  99                 ITextSelection selection= getSelection();
 100                 final IDocument document= getDocument();
 101
 102                 if (document != null) {
 103
 104                         final int offset= selection.getOffset();
 105                         final int length= selection.getLength();
 106                         final Position end= new Position(offset + length);
 107                         final int firstLine, nLines;
 108                         fCaretOffset= -1;
 109
 110                         try {
 111                                 document.addPosition(end);
 112                                 firstLine= document.getLineOfOffset(offset);
 113                                 // check for marginal (zero-length) lines
 114                                 int minusOne= length == 0 ? 0 : 1;
 115                                 nLines= document.getLineOfOffset(offset + length - minusOne) - firstLine + 1;
 116                         } catch (BadLocationException e) {
 117                                 // will only happen on concurrent modification
 118                           PHPeclipsePlugin.log(new Status(IStatus.ERROR, PHPeclipsePlugin.getPluginId(), IStatus.OK, "", e)); //$NON-NLS-1$
 119                                 return;
 120                         }
 121
 122                         Runnable runnable= new Runnable() {
 123                                 public void run() {
 124                                         IRewriteTarget target= (IRewriteTarget)getTextEditor().getAdapter(IRewriteTarget.class);
 125                                         if (target != null) {
 126                                                 target.beginCompoundChange();
 127                                                 target.setRedraw(false);
 128                                         }
 129
 130                                         try {
 131                                                 JavaHeuristicScanner scanner= new JavaHeuristicScanner(document);
 132                                                 JavaIndenter indenter= new JavaIndenter(document, scanner);
 133                                                 boolean hasChanged= false;
 134                                                 for (int i= 0; i < nLines; i++) {
 135                                                         hasChanged |= indentLine(document, firstLine + i, offset, indenter, scanner);
 136                                                 }
 137
 138                                                 // update caret position: move to new position when indenting just one line
 139                                                 // keep selection when indenting multiple
 140                                                 int newOffset, newLength;
 141                                                 if (fIsTabAction) {
 142                                                         newOffset= fCaretOffset;
 143                                                         newLength= 0;
 144                                                 } else if (nLines > 1) {
 145                                                         newOffset= offset;
 146                                                         newLength= end.getOffset() - offset;
 147                                                 } else {
 148                                                         newOffset= fCaretOffset;
 149                                                         newLength= 0;
 150                                                 }
 151
 152                                                 // always reset the selection if anything was replaced
 153                                                 // but not when we had a singleline nontab invocation
 154                                                 if (newOffset != -1 && (hasChanged || newOffset != offset || newLength != length))
 155                                                         selectAndReveal(newOffset, newLength);
 156
 157                                                 document.removePosition(end);
 158                                         } catch (BadLocationException e) {
 159                                                 // will only happen on concurrent modification
 160                                           PHPeclipsePlugin.log(new Status(IStatus.ERROR, PHPeclipsePlugin.getPluginId(), IStatus.OK, "ConcurrentModification in IndentAction", e)); //$NON-NLS-1$
 161
 162                                         } finally {
 163
 164                                                 if (target != null) {
 165                                                         target.endCompoundChange();
 166                                                         target.setRedraw(true);
 167                                                 }
 168                                         }
 169                                 }
 170                         };
 171
 172                         if (nLines > 50) {
 173                                 Display display= getTextEditor().getEditorSite().getWorkbenchWindow().getShell().getDisplay();
 174                                 BusyIndicator.showWhile(display, runnable);
 175                         } else
 176                                 runnable.run();
 177
 178                 }
 179         }
 180
 181         /**
 182          * Selects the given range on the editor.
 183          *
 184          * @param newOffset the selection offset
 185          * @param newLength the selection range
 186          */
 187         private void selectAndReveal(int newOffset, int newLength) {
 188                 Assert.isTrue(newOffset >= 0);
 189                 Assert.isTrue(newLength >= 0);
 190                 ITextEditor editor= getTextEditor();
 191                 if (editor instanceof PHPEditor) {
 192                         ISourceViewer viewer= ((PHPEditor)editor).getViewer();
 193                         if (viewer != null)
 194                                 viewer.setSelectedRange(newOffset, newLength);
 195                 } else
 196                         // this is too intrusive, but will never get called anyway
 197                         getTextEditor().selectAndReveal(newOffset, newLength);
 198
 199         }
 200
 201         /**
 202          * Indents a single line using the java heuristic scanner. Javadoc and multiline comments are
 203          * indented as specified by the <code>JavaDocAutoIndentStrategy</code>.
 204          *
 205          * @param document the document
 206          * @param line the line to be indented
 207          * @param caret the caret position
 208          * @param indenter the java indenter
 209          * @param scanner the heuristic scanner
 210          * @return <code>true</code> if <code>document</code> was modified, <code>false</code> otherwise
 211          * @throws BadLocationException if the document got changed concurrently
 212          */
 213         private boolean indentLine(IDocument document, int line, int caret, JavaIndenter indenter, JavaHeuristicScanner scanner) throws BadLocationException {
 214                 IRegion currentLine= document.getLineInformation(line);
 215                 int offset= currentLine.getOffset();
 216                 int wsStart= offset; // where we start searching for non-WS; after the "//" in single line comments
 217
 218                 String indent= null;
 219                 if (offset < document.getLength()) {
 220                         ITypedRegion partition= TextUtilities.getPartition(document, IPHPPartitions.PHP_PARTITIONING, offset, true);
 221                         String type= partition.getType();
 222                         if (type.equals(IPHPPartitions.PHP_PHPDOC_COMMENT) || type.equals(IPHPPartitions.PHP_MULTILINE_COMMENT)) {
 223
 224                                 // TODO this is a hack
 225                                 // what I want to do
 226 //                              new JavaDocAutoIndentStrategy().indentLineAtOffset(document, offset);
 227 //                              return;
 228
 229                                 int start= 0;
 230                                 if (line > 0) {
 231
 232                                         IRegion previousLine= document.getLineInformation(line - 1);
 233                                         start= previousLine.getOffset() + previousLine.getLength();
 234                                 }
 235
 236                                 DocumentCommand command= new DocumentCommand() {};
 237                                 command.text= "\n"; //$NON-NLS-1$
 238                                 command.offset= start;
 239                                 new JavaDocAutoIndentStrategy(IPHPPartitions.PHP_PARTITIONING).customizeDocumentCommand(document, command);
 240                                 int to= 1;
 241                                 while (to < command.text.length() && Character.isWhitespace(command.text.charAt(to)))
 242                                         to++;
 243                                 indent= command.text.substring(1, to);
 244
 245                         } else if (!fIsTabAction && partition.getOffset() == offset && type.equals(IPHPPartitions.PHP_SINGLELINE_COMMENT)) {
 246
 247                                 // line comment starting at position 0 -> indent inside
 248                                 int slashes= 2;
 249                                 while (slashes < document.getLength() - 1 && document.get(offset + slashes, 2).equals("//")) //$NON-NLS-1$
 250                                         slashes+= 2;
 251
 252                                 wsStart= offset + slashes;
 253
 254                                 StringBuffer computed= indenter.computeIndentation(offset);
 255                                 int tabSize= PHPeclipsePlugin.getDefault().getPreferenceStore().getInt(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH);
 256                                 while (slashes > 0 && computed.length() > 0) {
 257                                         char c= computed.charAt(0);
 258                                         if (c == '\t')
 259                                                 if (slashes > tabSize)
 260                                                         slashes-= tabSize;
 261                                                 else
 262                                                         break;
 263                                         else if (c == ' ')
 264                                                 slashes--;
 265                                         else break;
 266
 267                                         computed.deleteCharAt(0);
 268                                 }
 269
 270                                 indent= document.get(offset, wsStart - offset) + computed;
 271
 272                         }
 273                 }
 274
 275                 // standard java indentation
 276                 if (indent == null) {
 277                         StringBuffer computed= indenter.computeIndentation(offset);
 278                         if (computed != null)
 279                                 indent= computed.toString();
 280                         else
 281                                 indent= new String();
 282                 }
 283
 284                 // change document:
 285                 // get current white space
 286                 int lineLength= currentLine.getLength();
 287                 int end= scanner.findNonWhitespaceForwardInAnyPartition(wsStart, offset + lineLength);
 288                 if (end == JavaHeuristicScanner.NOT_FOUND)
 289                         end= offset + lineLength;
 290                 int length= end - offset;
 291                 String currentIndent= document.get(offset, length);
 292
 293                 // if we are right before the text start / line end, and already after the insertion point
 294                 // then just insert a tab.
 295                 if (fIsTabAction && caret == end && whiteSpaceLength(currentIndent) >= whiteSpaceLength(indent)) {
 296                         String tab= getTabEquivalent();
 297                         document.replace(caret, 0, tab);
 298                         fCaretOffset= caret + tab.length();
 299                         return true;
 300                 }
 301
 302                 // set the caret offset so it can be used when setting the selection
 303                 if (caret >= offset && caret <= end)
 304                         fCaretOffset= offset + indent.length();
 305                 else
 306                         fCaretOffset= -1;
 307
 308                 // only change the document if it is a real change
 309                 if (!indent.equals(currentIndent)) {
 310                         String deletedText= document.get(offset, length);
 311                         document.replace(offset, length, indent);
 312
 313                         if (fIsTabAction && indent.length() > currentIndent.length() && PHPeclipsePlugin.getDefault().getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_BACKSPACE)) {
 314                                 ITextEditor editor= getTextEditor();
 315                                 if (editor != null) {
 316                                         final SmartBackspaceManager manager= (SmartBackspaceManager) editor.getAdapter(SmartBackspaceManager.class);
 317                                         if (manager != null) {
 318                                                 try {
 319                                                         // restore smart portion
 320                                                         ReplaceEdit smart= new ReplaceEdit(offset, indent.length(), deletedText);
 321
 322                                                         final UndoSpec spec= new UndoSpec(
 323                                                                         offset + indent.length(),
 324                                                                         new Region(caret, 0),
 325                                                                         new TextEdit[] { smart },
 326                                                                         2,
 327                                                                         null);
 328                                                         manager.register(spec);
 329                                                 } catch (MalformedTreeException e) {
 330                                                         // log & ignore
 331                                                   PHPeclipsePlugin.log(new Status(IStatus.ERROR, PHPeclipsePlugin.getPluginId(), IStatus.OK, "Illegal smart backspace action", e)); //$NON-NLS-1$
 332                                                 }
 333                                         }
 334                                 }
 335                         }
 336
 337
 338                         return true;
 339                 } else
 340                         return false;
 341         }
 342
 343         /**
 344          * Returns the size in characters of a string. All characters count one, tabs count the editor's
 345          * preference for the tab display
 346          *
 347          * @param indent the string to be measured.
 348          * @return
 349          */
 350         private int whiteSpaceLength(String indent) {
 351                 if (indent == null)
 352                         return 0;
 353                 else {
 354                         int size= 0;
 355                         int l= indent.length();
 356                         int tabSize= PHPeclipsePlugin.getDefault().getPreferenceStore().getInt(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH);
 357
 358                         for (int i= 0; i < l; i++)
 359                                 size += indent.charAt(i) == '\t' ? tabSize : 1;
 360                         return size;
 361                 }
 362         }
 363
 364         /**
 365          * Returns a tab equivalent, either as a tab character or as spaces, depending on the editor and
 366          * formatter preferences.
 367          *
 368          * @return a string representing one tab in the editor, never <code>null</code>
 369          */
 370         private String getTabEquivalent() {
 371                 String tab;
 372                 if (PHPeclipsePlugin.getDefault().getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SPACES_FOR_TABS)) {
 373                         int size= JavaCore.getPlugin().getPluginPreferences().getInt(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE);
 374                         StringBuffer buf= new StringBuffer();
 375                         for (int i= 0; i< size; i++)
 376                                 buf.append(' ');
 377                         tab= buf.toString();
 378                 } else
 379                         tab= "\t"; //$NON-NLS-1$
 380
 381                 return tab;
 382         }
 383
 384         /**
 385          * Returns the editor's selection provider.
 386          *
 387          * @return the editor's selection provider or <code>null</code>
 388          */
 389         private ISelectionProvider getSelectionProvider() {
 390                 ITextEditor editor= getTextEditor();
 391                 if (editor != null) {
 392                         return editor.getSelectionProvider();
 393                 }
 394                 return null;
 395         }
 396
 397         /*
 398          * @see org.eclipse.ui.texteditor.IUpdate#update()
 399          */
 400         public void update() {
 401                 super.update();
 402
 403                 if (isEnabled())
 404                         if (fIsTabAction)
 405                                 setEnabled(canModifyEditor() && isSmartMode() && isValidSelection());
 406                         else
 407                                 setEnabled(canModifyEditor() && !getSelection().isEmpty());
 408         }
 409
 410         /**
 411          * Returns if the current selection is valid, i.e. whether it is empty and the caret in the
 412          * whitespace at the start of a line, or covers multiple lines.
 413          *
 414          * @return <code>true</code> if the selection is valid for an indent operation
 415          */
 416         private boolean isValidSelection() {
 417                 ITextSelection selection= getSelection();
 418                 if (selection.isEmpty())
 419                         return false;
 420
 421                 int offset= selection.getOffset();
 422                 int length= selection.getLength();
 423
 424                 IDocument document= getDocument();
 425                 if (document == null)
 426                         return false;
 427
 428                 try {
 429                         IRegion firstLine= document.getLineInformationOfOffset(offset);
 430                         int lineOffset= firstLine.getOffset();
 431
 432                         // either the selection has to be empty and the caret in the WS at the line start
 433                         // or the selection has to extend over multiple lines
 434                         if (length == 0)
 435                                 return document.get(lineOffset, offset - lineOffset).trim().length() == 0;
 436                         else
 437 //                              return lineOffset + firstLine.getLength() < offset + length;
 438                                 return false; // only enable for empty selections for now
 439
 440                 } catch (BadLocationException e) {
 441                 }
 442
 443                 return false;
 444         }
 445
 446         /**
 447          * Returns the smart preference state.
 448          *
 449          * @return <code>true</code> if smart mode is on, <code>false</code> otherwise
 450          */
 451         private boolean isSmartMode() {
 452                 ITextEditor editor= getTextEditor();
 453
 454                 if (editor instanceof ITextEditorExtension3)
 455                         return ((ITextEditorExtension3) editor).getInsertMode() == ITextEditorExtension3.SMART_INSERT;
 456
 457                 return false;
 458         }
 459
 460         /**
 461          * Returns the document currently displayed in the editor, or <code>null</code> if none can be
 462          * obtained.
 463          *
 464          * @return the current document or <code>null</code>
 465          */
 466         private IDocument getDocument() {
 467
 468                 ITextEditor editor= getTextEditor();
 469                 if (editor != null) {
 470
 471                         IDocumentProvider provider= editor.getDocumentProvider();
 472                         IEditorInput input= editor.getEditorInput();
 473                         if (provider != null && input != null)
 474                                 return provider.getDocument(input);
 475
 476                 }
 477                 return null;
 478         }
 479
 480         /**
 481          * Returns the selection on the editor or an invalid selection if none can be obtained. Returns
 482          * never <code>null</code>.
 483          *
 484          * @return the current selection, never <code>null</code>
 485          */
 486         private ITextSelection getSelection() {
 487                 ISelectionProvider provider= getSelectionProvider();
 488                 if (provider != null) {
 489
 490                         ISelection selection= provider.getSelection();
 491                         if (selection instanceof ITextSelection)
 492                                 return (ITextSelection) selection;
 493                 }
 494
 495                 // null object
 496                 return TextSelection.emptySelection();
 497         }
 498
 499 }