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