708a7b6c1541117a599a2afe8be4254c6f83d775
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpdt / internal / ui / text / phpdoc / JavaDocAutoIndentStrategy.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
12 package net.sourceforge.phpdt.internal.ui.text.phpdoc;
13
14 import java.text.BreakIterator;
15
16 import net.sourceforge.phpdt.core.ICompilationUnit;
17 import net.sourceforge.phpdt.core.IJavaElement;
18 import net.sourceforge.phpdt.core.IMethod;
19 import net.sourceforge.phpdt.core.ISourceRange;
20 import net.sourceforge.phpdt.core.IType;
21 import net.sourceforge.phpdt.internal.corext.util.Strings;
22 import net.sourceforge.phpdt.ui.CodeGeneration;
23 import net.sourceforge.phpdt.ui.IWorkingCopyManager;
24 import net.sourceforge.phpdt.ui.PreferenceConstants;
25 //import net.sourceforge.phpeclipse.PHPeclipsePlugin;
26 import net.sourceforge.phpeclipse.ui.WebUI;
27
28 import org.eclipse.core.runtime.CoreException;
29 import org.eclipse.core.runtime.Preferences;
30 import org.eclipse.jface.preference.IPreferenceStore;
31 import org.eclipse.jface.text.BadLocationException;
32 import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy;
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.ITypedRegion;
37 import org.eclipse.jface.text.TextUtilities;
38 import org.eclipse.ui.IEditorPart;
39 import org.eclipse.ui.IWorkbenchPage;
40 import org.eclipse.ui.IWorkbenchWindow;
41 import org.eclipse.ui.PlatformUI;
42 import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
43 import org.eclipse.ui.texteditor.ITextEditorExtension3;
44
45 /**
46  * Auto indent strategy for java doc comments
47  */
48 public class JavaDocAutoIndentStrategy extends
49                 DefaultIndentLineAutoEditStrategy {
50
51         private String fPartitioning;
52
53         /**
54          * Creates a new Javadoc auto indent strategy for the given document
55          * partitioning.
56          * 
57          * @param partitioning
58          *            the document partitioning
59          */
60         public JavaDocAutoIndentStrategy(String partitioning) {
61                 fPartitioning = partitioning;
62         }
63
64         private static String getLineDelimiter(IDocument document) {
65                 try {
66                         if (document.getNumberOfLines() > 1)
67                                 return document.getLineDelimiter(0);
68                 } catch (BadLocationException e) {
69                         WebUI.log(e);
70                 }
71
72                 return System.getProperty("line.separator"); //$NON-NLS-1$
73         }
74
75         /**
76          * Copies the indentation of the previous line and add a star. If the
77          * javadoc just started on this line add standard method tags and close the
78          * javadoc.
79          * 
80          * @param d
81          *            the document to work on
82          * @param c
83          *            the command to deal with
84          */
85         private void jdocIndentAfterNewLine(IDocument d, DocumentCommand c) {
86
87                 if (c.offset == -1 || d.getLength() == 0)
88                         return;
89
90                 try {
91                         // find start of line
92                         int p = (c.offset == d.getLength() ? c.offset - 1 : c.offset);
93                         IRegion info = d.getLineInformationOfOffset(p);
94                         int start = info.getOffset();
95
96                         // find white spaces
97                         int end = findEndOfWhiteSpace(d, start, c.offset);
98
99                         StringBuffer buf = new StringBuffer(c.text);
100                         if (end >= start) { // 1GEYL1R: ITPJUI:ALL - java doc edit smartness
101                                                                 // not work for class comments
102                                 // append to input
103                                 String indentation = jdocExtractLinePrefix(d, d
104                                                 .getLineOfOffset(c.offset));
105                                 buf.append(indentation);
106                                 if (end < c.offset) {
107                                         if (d.getChar(end) == '/') {
108                                                 // javadoc started on this line
109                                                 buf.append(" * "); //$NON-NLS-1$
110
111                                                 if (WebUI
112                                                                 .getDefault()
113                                                                 .getPreferenceStore()
114                                                                 .getBoolean(
115                                                                                 PreferenceConstants.EDITOR_CLOSE_JAVADOCS)
116                                                                 && isNewComment(d, c.offset, fPartitioning)) {
117                                                         String lineDelimiter = getLineDelimiter(d);
118
119                                                         String endTag = lineDelimiter + indentation + " */"; //$NON-NLS-1$
120                                                         d.replace(c.offset, 0, endTag); //$NON-NLS-1$
121                                                         // evaluate method signature
122                                                         ICompilationUnit unit = getCompilationUnit();
123
124                                                         // if
125                                                         // (PHPeclipsePlugin.getDefault().getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_ADD_JAVADOC_TAGS)
126                                                         // &&
127                                                         // unit != null)
128                                                         // {
129                                                         // try {
130                                                         // JavaModelUtil.reconcile(unit);
131                                                         // String string= createJavaDocTags(d, c,
132                                                         // indentation, lineDelimiter, unit);
133                                                         // if (string != null) {
134                                                         // d.replace(c.offset, 0, string);
135                                                         // }
136                                                         // } catch (CoreException e) {
137                                                         // // ignore
138                                                         // }
139                                                         // }
140                                                 }
141
142                                         }
143                                 }
144                         }
145
146                         c.text = buf.toString();
147
148                 } catch (BadLocationException excp) {
149                         // stop work
150                 }
151         }
152
153         private String createJavaDocTags(IDocument document,
154                         DocumentCommand command, String indentation, String lineDelimiter,
155                         ICompilationUnit unit) throws CoreException, BadLocationException {
156                 IJavaElement element = unit.getElementAt(command.offset);
157                 if (element == null)
158                         return null;
159
160                 switch (element.getElementType()) {
161                 case IJavaElement.TYPE:
162                         return createTypeTags(document, command, indentation,
163                                         lineDelimiter, (IType) element);
164
165                 case IJavaElement.METHOD:
166                         return createMethodTags(document, command, indentation,
167                                         lineDelimiter, (IMethod) element);
168
169                 default:
170                         return null;
171                 }
172         }
173
174         /*
175          * Removes start and end of a comment and corrects indentation and line
176          * delimiters.
177          */
178         private String prepareTemplateComment(String comment, String indentation,
179                         String lineDelimiter) {
180                 // trim comment start and end if any
181                 if (comment.endsWith("*/")) //$NON-NLS-1$
182                         comment = comment.substring(0, comment.length() - 2);
183                 comment = comment.trim();
184                 if (comment.startsWith("/*")) { //$NON-NLS-1$
185                         if (comment.length() > 2 && comment.charAt(2) == '*') {
186                                 comment = comment.substring(3); // remove '/**'
187                         } else {
188                                 comment = comment.substring(2); // remove '/*'
189                         }
190                 }
191                 // return Strings.changeIndent(comment, 0,
192                 // CodeFormatterUtil.getTabWidth(), indentation, lineDelimiter);
193                 return Strings.changeIndent(comment, 0, getTabWidth(), indentation,
194                                 lineDelimiter);
195         }
196
197         public static int getTabWidth() {
198                 Preferences preferences = WebUI.getDefault()
199                                 .getPluginPreferences();
200                 return preferences
201                                 .getInt(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH);
202         }
203
204         private String createTypeTags(IDocument document, DocumentCommand command,
205                         String indentation, String lineDelimiter, IType type)
206                         throws CoreException {
207                 String comment = CodeGeneration.getTypeComment(type
208                                 .getCompilationUnit(), type.getTypeQualifiedName('.'),
209                                 lineDelimiter);
210                 if (comment != null) {
211                         return prepareTemplateComment(comment.trim(), indentation,
212                                         lineDelimiter);
213                 }
214                 return null;
215         }
216
217         private String createMethodTags(IDocument document,
218                         DocumentCommand command, String indentation, String lineDelimiter,
219                         IMethod method) throws CoreException, BadLocationException {
220                 IRegion partition = TextUtilities.getPartition(document, fPartitioning,
221                                 command.offset, false);
222                 ISourceRange sourceRange = method.getSourceRange();
223                 if (sourceRange == null
224                                 || sourceRange.getOffset() != partition.getOffset())
225                         return null;
226
227                 // IMethod inheritedMethod= getInheritedMethod(method);
228                 // String comment= CodeGeneration.getMethodComment(method,
229                 // inheritedMethod, lineDelimiter);
230                 // if (comment != null) {
231                 // comment= comment.trim();
232                 // boolean javadocComment= comment.startsWith("/**"); //$NON-NLS-1$
233                 // boolean isJavaDoc= partition.getLength() >= 3 &&
234                 // document.get(partition.getOffset(), 3).equals("/**"); //$NON-NLS-1$
235                 // if (javadocComment == isJavaDoc) {
236                 // return prepareTemplateComment(comment, indentation, lineDelimiter);
237                 // }
238                 // }
239                 return null;
240         }
241
242         /**
243          * Returns the method inherited from, <code>null</code> if method is newly
244          * defined.
245          */
246         // private static IMethod getInheritedMethod(IMethod method) throws
247         // JavaModelException {
248         // IType declaringType= method.getDeclaringType();
249         // ITypeHierarchy typeHierarchy=
250         // SuperTypeHierarchyCache.getTypeHierarchy(declaringType);
251         // return JavaModelUtil.findMethodDeclarationInHierarchy(typeHierarchy,
252         // declaringType,
253         // method.getElementName(), method.getParameterTypes(),
254         // method.isConstructor());
255         // }
256         protected void jdocIndentForCommentEnd(IDocument d, DocumentCommand c) {
257                 if (c.offset < 2 || d.getLength() == 0) {
258                         return;
259                 }
260                 try {
261                         if ("* ".equals(d.get(c.offset - 2, 2))) { //$NON-NLS-1$
262                                 // modify document command
263                                 c.length++;
264                                 c.offset--;
265                         }
266                 } catch (BadLocationException excp) {
267                         // stop work
268                 }
269         }
270
271         /**
272          * Guesses if the command operates within a newly created javadoc comment or
273          * not. If in doubt, it will assume that the javadoc is new.
274          */
275         private static boolean isNewComment(IDocument document, int commandOffset,
276                         String partitioning) {
277
278                 try {
279                         int lineIndex = document.getLineOfOffset(commandOffset) + 1;
280                         if (lineIndex >= document.getNumberOfLines())
281                                 return true;
282
283                         IRegion line = document.getLineInformation(lineIndex);
284                         ITypedRegion partition = TextUtilities.getPartition(document,
285                                         partitioning, commandOffset, false);
286                         int partitionEnd = partition.getOffset() + partition.getLength();
287                         if (line.getOffset() >= partitionEnd)
288                                 return false;
289
290                         if (document.getLength() == partitionEnd)
291                                 return true; // partition goes to end of document - probably
292                                                                 // a new comment
293
294                         String comment = document.get(partition.getOffset(), partition
295                                         .getLength());
296                         if (comment.indexOf("/*", 2) != -1) //$NON-NLS-1$
297                                 return true; // enclosed another comment -> probably a new
298                                                                 // comment
299
300                         return false;
301
302                 } catch (BadLocationException e) {
303                         return false;
304                 }
305         }
306
307         private boolean isSmartMode() {
308                 IWorkbenchPage page = WebUI.getActivePage();
309                 if (page != null) {
310                         IEditorPart part = page.getActiveEditor();
311                         if (part instanceof ITextEditorExtension3) {
312                                 ITextEditorExtension3 extension = (ITextEditorExtension3) part;
313                                 return extension.getInsertMode() == ITextEditorExtension3.SMART_INSERT;
314                         }
315                 }
316                 return false;
317         }
318
319         /*
320          * @see IAutoIndentStrategy#customizeDocumentCommand
321          */
322         public void customizeDocumentCommand(IDocument document,
323                         DocumentCommand command) {
324
325                 if (!isSmartMode())
326                         return;
327
328                 try {
329
330                         if (command.text != null && command.length == 0) {
331                                 String[] lineDelimiters = document.getLegalLineDelimiters();
332                                 int index = TextUtilities
333                                                 .endsWith(lineDelimiters, command.text);
334                                 if (index > -1) {
335                                         // ends with line delimiter
336                                         if (lineDelimiters[index].equals(command.text))
337                                                 // just the line delimiter
338                                                 jdocIndentAfterNewLine(document, command);
339                                         return;
340                                 }
341                         }
342
343                         if (command.text != null && command.text.equals("/")) { //$NON-NLS-1$
344                                 jdocIndentForCommentEnd(document, command);
345                                 return;
346                         }
347
348                         ITypedRegion partition = TextUtilities.getPartition(document,
349                                         fPartitioning, command.offset, true);
350                         int partitionStart = partition.getOffset();
351                         int partitionEnd = partition.getLength() + partitionStart;
352
353                         String text = command.text;
354                         int offset = command.offset;
355                         int length = command.length;
356
357                         // partition change
358                         final int PREFIX_LENGTH = "/*".length(); //$NON-NLS-1$
359                         final int POSTFIX_LENGTH = "*/".length(); //$NON-NLS-1$
360                         if ((offset < partitionStart + PREFIX_LENGTH || offset + length > partitionEnd
361                                         - POSTFIX_LENGTH)
362                                         || text != null
363                                         && text.length() >= 2
364                                         && ((text.indexOf("*/") != -1) || (document.getChar(offset) == '*' && text.startsWith("/")))) //$NON-NLS-1$ //$NON-NLS-2$
365                                 return;
366
367                         if (command.text == null || command.text.length() == 0)
368                                 jdocHandleBackspaceDelete(document, command);
369
370                         else if (command.text != null && command.length == 0
371                                         && command.text.length() > 0)
372                                 jdocWrapParagraphOnInsert(document, command);
373
374                 } catch (BadLocationException e) {
375                         WebUI.log(e);
376                 }
377         }
378
379         private void flushCommand(IDocument document, DocumentCommand command)
380                         throws BadLocationException {
381
382                 if (!command.doit)
383                         return;
384
385                 document.replace(command.offset, command.length, command.text);
386
387                 command.doit = false;
388                 if (command.text != null)
389                         command.offset += command.text.length();
390                 command.length = 0;
391                 command.text = null;
392         }
393
394         protected void jdocWrapParagraphOnInsert(IDocument document,
395                         DocumentCommand command) throws BadLocationException {
396
397                 // Assert.isTrue(command.length == 0);
398                 // Assert.isTrue(command.text != null && command.text.length() == 1);
399
400                 if (!getPreferenceStore().getBoolean(
401                                 PreferenceConstants.EDITOR_FORMAT_JAVADOCS))
402                         return;
403
404                 int line = document.getLineOfOffset(command.offset);
405                 IRegion region = document.getLineInformation(line);
406                 int lineOffset = region.getOffset();
407                 int lineLength = region.getLength();
408
409                 String lineContents = document.get(lineOffset, lineLength);
410                 StringBuffer buffer = new StringBuffer(lineContents);
411                 int start = command.offset - lineOffset;
412                 int end = command.length + start;
413                 buffer.replace(start, end, command.text);
414
415                 // handle whitespace
416                 if (command.text != null && command.text.length() != 0
417                                 && command.text.trim().length() == 0) {
418
419                         String endOfLine = document.get(command.offset, lineOffset
420                                         + lineLength - command.offset);
421
422                         // end of line
423                         if (endOfLine.length() == 0) {
424                                 // move caret to next line
425                                 flushCommand(document, command);
426
427                                 if (isLineTooShort(document, line)) {
428                                         int[] caretOffset = { command.offset };
429                                         jdocWrapParagraphFromLine(document, line, caretOffset,
430                                                         false);
431                                         command.offset = caretOffset[0];
432                                         return;
433                                 }
434
435                                 // move caret to next line if possible
436                                 if (line < document.getNumberOfLines() - 1
437                                                 && isJavaDocLine(document, line + 1)) {
438                                         String lineDelimiter = document.getLineDelimiter(line);
439                                         String nextLinePrefix = jdocExtractLinePrefix(document,
440                                                         line + 1);
441                                         command.offset += lineDelimiter.length()
442                                                         + nextLinePrefix.length();
443                                 }
444                                 return;
445
446                                 // inside whitespace at end of line
447                         } else if (endOfLine.trim().length() == 0) {
448                                 // simply insert space
449                                 return;
450                         }
451                 }
452
453                 // change in prefix region
454                 String prefix = jdocExtractLinePrefix(document, line);
455                 boolean wrapAlways = command.offset >= lineOffset
456                                 && command.offset <= lineOffset + prefix.length();
457
458                 // must insert the text now because it may include whitepace
459                 flushCommand(document, command);
460
461                 if (wrapAlways
462                                 || calculateDisplayedWidth(buffer.toString()) > getMargin()
463                                 || isLineTooShort(document, line)) {
464                         int[] caretOffset = { command.offset };
465                         jdocWrapParagraphFromLine(document, line, caretOffset, wrapAlways);
466
467                         if (!wrapAlways)
468                                 command.offset = caretOffset[0];
469                 }
470         }
471
472         /**
473          * Method jdocWrapParagraphFromLine.
474          * 
475          * @param document
476          * @param line
477          * @param always
478          */
479         private void jdocWrapParagraphFromLine(IDocument document, int line,
480                         int[] caretOffset, boolean always) throws BadLocationException {
481
482                 String indent = jdocExtractLinePrefix(document, line);
483                 if (!always) {
484                         if (!indent.trim().startsWith("*")) //$NON-NLS-1$
485                                 return;
486
487                         if (indent.trim().startsWith("*/")) //$NON-NLS-1$
488                                 return;
489
490                         if (!isLineTooLong(document, line)
491                                         && !isLineTooShort(document, line))
492                                 return;
493                 }
494
495                 boolean caretRelativeToParagraphOffset = false;
496                 int caret = caretOffset[0];
497
498                 int caretLine = document.getLineOfOffset(caret);
499                 int lineOffset = document.getLineOffset(line);
500                 int paragraphOffset = lineOffset + indent.length();
501                 if (paragraphOffset < caret) {
502                         caret -= paragraphOffset;
503                         caretRelativeToParagraphOffset = true;
504                 } else {
505                         caret -= lineOffset;
506                 }
507
508                 StringBuffer buffer = new StringBuffer();
509                 int currentLine = line;
510                 while (line == currentLine || isJavaDocLine(document, currentLine)) {
511
512                         if (buffer.length() != 0
513                                         && !Character.isWhitespace(buffer
514                                                         .charAt(buffer.length() - 1))) {
515                                 buffer.append(' ');
516                                 if (currentLine <= caretLine) {
517                                         // in this case caretRelativeToParagraphOffset is always
518                                         // true
519                                         ++caret;
520                                 }
521                         }
522
523                         String string = getLineContents(document, currentLine);
524                         buffer.append(string);
525                         currentLine++;
526                 }
527                 String paragraph = buffer.toString();
528
529                 if (paragraph.trim().length() == 0)
530                         return;
531
532                 caretOffset[0] = caretRelativeToParagraphOffset ? caret : 0;
533                 String delimiter = document.getLineDelimiter(0);
534                 String wrapped = formatParagraph(paragraph, caretOffset, indent,
535                                 delimiter, getMargin());
536
537                 int beginning = document.getLineOffset(line);
538                 int end = document.getLineOffset(currentLine);
539                 document.replace(beginning, end - beginning, wrapped.toString());
540
541                 caretOffset[0] = caretRelativeToParagraphOffset ? caretOffset[0]
542                                 + beginning : caret + beginning;
543         }
544
545         /**
546          * Line break iterator to handle whitespaces as first class citizens.
547          */
548         private static class LineBreakIterator {
549
550                 private final String fString;
551
552                 private final BreakIterator fIterator = BreakIterator.getLineInstance();
553
554                 private int fStart;
555
556                 private int fEnd;
557
558                 private int fBufferedEnd;
559
560                 public LineBreakIterator(String string) {
561                         fString = string;
562                         fIterator.setText(string);
563                 }
564
565                 public int first() {
566                         fBufferedEnd = -1;
567                         fStart = fIterator.first();
568                         return fStart;
569                 }
570
571                 public int next() {
572
573                         if (fBufferedEnd != -1) {
574                                 fStart = fEnd;
575                                 fEnd = fBufferedEnd;
576                                 fBufferedEnd = -1;
577                                 return fEnd;
578                         }
579
580                         fStart = fEnd;
581                         fEnd = fIterator.next();
582
583                         if (fEnd == BreakIterator.DONE)
584                                 return fEnd;
585
586                         final String string = fString.substring(fStart, fEnd);
587
588                         // whitespace
589                         if (string.trim().length() == 0)
590                                 return fEnd;
591
592                         final String word = string.trim();
593                         if (word.length() == string.length())
594                                 return fEnd;
595
596                         // suspected whitespace
597                         fBufferedEnd = fEnd;
598                         return fStart + word.length();
599                 }
600         }
601
602         /**
603          * Formats a paragraph, using break iterator.
604          * 
605          * @param offset
606          *            an offset within the paragraph, which will be updated with
607          *            respect to formatting.
608          */
609         private static String formatParagraph(String paragraph, int[] offset,
610                         String prefix, String lineDelimiter, int margin) {
611
612                 LineBreakIterator iterator = new LineBreakIterator(paragraph);
613
614                 StringBuffer paragraphBuffer = new StringBuffer();
615                 StringBuffer lineBuffer = new StringBuffer();
616                 StringBuffer whiteSpaceBuffer = new StringBuffer();
617
618                 int index = offset[0];
619                 int indexBuffer = -1;
620
621                 // line delimiter could be null
622                 if (lineDelimiter == null)
623                         lineDelimiter = ""; //$NON-NLS-1$
624
625                 for (int start = iterator.first(), end = iterator.next(); end != BreakIterator.DONE; start = end, end = iterator
626                                 .next()) {
627
628                         String word = paragraph.substring(start, end);
629
630                         // word is whitespace
631                         if (word.trim().length() == 0) {
632                                 whiteSpaceBuffer.append(word);
633
634                                 // first word of line is always appended
635                         } else if (lineBuffer.length() == 0) {
636                                 lineBuffer.append(prefix);
637                                 lineBuffer.append(whiteSpaceBuffer.toString());
638                                 lineBuffer.append(word);
639
640                         } else {
641                                 String line = lineBuffer.toString()
642                                                 + whiteSpaceBuffer.toString() + word.toString();
643
644                                 // margin exceeded
645                                 if (calculateDisplayedWidth(line) > margin) {
646                                         // flush line buffer and wrap paragraph
647                                         paragraphBuffer.append(lineBuffer.toString());
648                                         paragraphBuffer.append(lineDelimiter);
649                                         lineBuffer.setLength(0);
650                                         lineBuffer.append(prefix);
651                                         lineBuffer.append(word);
652
653                                         // flush index buffer
654                                         if (indexBuffer != -1) {
655                                                 offset[0] = indexBuffer;
656                                                 // correct for caret in whitespace at the end of line
657                                                 if (whiteSpaceBuffer.length() != 0 && index < start
658                                                                 && index >= start - whiteSpaceBuffer.length())
659                                                         offset[0] -= (index - (start - whiteSpaceBuffer
660                                                                         .length()));
661                                                 indexBuffer = -1;
662                                         }
663
664                                         whiteSpaceBuffer.setLength(0);
665
666                                         // margin not exceeded
667                                 } else {
668                                         lineBuffer.append(whiteSpaceBuffer.toString());
669                                         lineBuffer.append(word);
670                                         whiteSpaceBuffer.setLength(0);
671                                 }
672                         }
673
674                         if (index >= start && index < end) {
675                                 indexBuffer = paragraphBuffer.length() + lineBuffer.length()
676                                                 + (index - start);
677                                 if (word.trim().length() != 0)
678                                         indexBuffer -= word.length();
679                         }
680                 }
681
682                 // flush line buffer
683                 paragraphBuffer.append(lineBuffer.toString());
684                 paragraphBuffer.append(lineDelimiter);
685
686                 // flush index buffer
687                 if (indexBuffer != -1)
688                         offset[0] = indexBuffer;
689
690                 // last position is not returned by break iterator
691                 else if (offset[0] == paragraph.length())
692                         offset[0] = paragraphBuffer.length() - lineDelimiter.length();
693
694                 return paragraphBuffer.toString();
695         }
696
697         private static IPreferenceStore getPreferenceStore() {
698                 return WebUI.getDefault().getPreferenceStore();
699         }
700
701         /**
702          * Returns the displayed width of a string, taking in account the displayed
703          * tab width. The result can be compared against the print margin.
704          */
705         private static int calculateDisplayedWidth(String string) {
706
707                 int tabWidth = getPreferenceStore()
708                                 .getInt(
709                                                 AbstractDecoratedTextEditorPreferenceConstants.EDITOR_TAB_WIDTH);
710                 if (tabWidth <= 0) {
711                         tabWidth = 2;
712                 }
713                 int column = 0;
714                 for (int i = 0; i < string.length(); i++)
715                         if ('\t' == string.charAt(i))
716                                 column += tabWidth - (column % tabWidth);
717                         else
718                                 column++;
719
720                 return column;
721         }
722
723         private String jdocExtractLinePrefix(IDocument d, int line)
724                         throws BadLocationException {
725
726                 IRegion region = d.getLineInformation(line);
727                 int lineOffset = region.getOffset();
728                 int index = findEndOfWhiteSpace(d, lineOffset, lineOffset
729                                 + d.getLineLength(line));
730                 if (d.getChar(index) == '*') {
731                         index++;
732                         if (index != lineOffset + region.getLength()
733                                         && d.getChar(index) == ' ')
734                                 index++;
735                 }
736                 return d.get(lineOffset, index - lineOffset);
737         }
738
739         private String getLineContents(IDocument d, int line)
740                         throws BadLocationException {
741                 int offset = d.getLineOffset(line);
742                 int length = d.getLineLength(line);
743                 String lineDelimiter = d.getLineDelimiter(line);
744                 if (lineDelimiter != null)
745                         length = length - lineDelimiter.length();
746                 String lineContents = d.get(offset, length);
747                 int trim = jdocExtractLinePrefix(d, line).length();
748                 return lineContents.substring(trim);
749         }
750
751         private static String getLine(IDocument document, int line)
752                         throws BadLocationException {
753                 IRegion region = document.getLineInformation(line);
754                 return document.get(region.getOffset(), region.getLength());
755         }
756
757         /**
758          * Returns <code>true</code> if the javadoc line is too short,
759          * <code>false</code> otherwise.
760          */
761         private boolean isLineTooShort(IDocument document, int line)
762                         throws BadLocationException {
763
764                 if (!isJavaDocLine(document, line + 1))
765                         return false;
766
767                 String nextLine = getLineContents(document, line + 1);
768                 if (nextLine.trim().length() == 0)
769                         return false;
770
771                 return true;
772         }
773
774         /**
775          * Returns <code>true</code> if the line is too long, <code>false</code>
776          * otherwise.
777          */
778         private boolean isLineTooLong(IDocument document, int line)
779                         throws BadLocationException {
780                 String lineContents = getLine(document, line);
781                 return calculateDisplayedWidth(lineContents) > getMargin();
782         }
783
784         private static int getMargin() {
785                 return getPreferenceStore()
786                                 .getInt(
787                                                 AbstractDecoratedTextEditorPreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN);
788         }
789
790         private static final String[] fgInlineTags = {
791                         "<b>", "<i>", "<em>", "<strong>", "<code>" //$NON-NLS-1$  //$NON-NLS-2$  //$NON-NLS-3$  //$NON-NLS-4$ //$NON-NLS-5$
792         };
793
794         private boolean isInlineTag(String string) {
795                 for (int i = 0; i < fgInlineTags.length; i++)
796                         if (string.startsWith(fgInlineTags[i]))
797                                 return true;
798                 return false;
799         }
800
801         /**
802          * returns true if the specified line is part of a paragraph and should be
803          * merged with the previous line.
804          */
805         private boolean isJavaDocLine(IDocument document, int line)
806                         throws BadLocationException {
807
808                 if (document.getNumberOfLines() < line)
809                         return false;
810
811                 int offset = document.getLineOffset(line);
812                 int length = document.getLineLength(line);
813                 int firstChar = findEndOfWhiteSpace(document, offset, offset + length);
814                 length -= firstChar - offset;
815                 String lineContents = document.get(firstChar, length);
816
817                 String prefix = lineContents.trim();
818                 if (!prefix.startsWith("*") || prefix.startsWith("*/")) //$NON-NLS-1$ //$NON-NLS-2$
819                         return false;
820
821                 lineContents = lineContents.substring(1).trim().toLowerCase();
822
823                 // preserve empty lines
824                 if (lineContents.length() == 0)
825                         return false;
826
827                 // preserve @TAGS
828                 if (lineContents.startsWith("@")) //$NON-NLS-1$
829                         return false;
830
831                 // preserve HTML tags which are not inline
832                 if (lineContents.startsWith("<") && !isInlineTag(lineContents)) //$NON-NLS-1$
833                         return false;
834
835                 return true;
836         }
837
838         protected void jdocHandleBackspaceDelete(IDocument document,
839                         DocumentCommand c) {
840
841                 if (!getPreferenceStore().getBoolean(
842                                 PreferenceConstants.EDITOR_FORMAT_JAVADOCS))
843                         return;
844
845                 try {
846                         String text = document.get(c.offset, c.length);
847                         int line = document.getLineOfOffset(c.offset);
848                         int lineOffset = document.getLineOffset(line);
849
850                         // erase line delimiter
851                         String lineDelimiter = document.getLineDelimiter(line);
852                         if (lineDelimiter != null && lineDelimiter.equals(text)) {
853
854                                 String prefix = jdocExtractLinePrefix(document, line + 1);
855
856                                 // strip prefix if any
857                                 if (prefix.length() > 0) {
858                                         int length = document.getLineDelimiter(line).length()
859                                                         + prefix.length();
860                                         document.replace(c.offset, length, null);
861
862                                         c.doit = false;
863                                         c.length = 0;
864                                         return;
865                                 }
866
867                                 // backspace: beginning of a javadoc line
868                         } else if (document.getChar(c.offset - 1) == '*'
869                                         && jdocExtractLinePrefix(document, line).length() - 1 >= c.offset
870                                                         - lineOffset) {
871
872                                 lineDelimiter = document.getLineDelimiter(line - 1);
873                                 String prefix = jdocExtractLinePrefix(document, line);
874                                 int length = (lineDelimiter != null ? lineDelimiter.length()
875                                                 : 0)
876                                                 + prefix.length();
877                                 document.replace(c.offset - length + 1, length, null);
878
879                                 c.doit = false;
880                                 c.offset -= length - 1;
881                                 c.length = 0;
882                                 return;
883
884                         } else {
885                                 document.replace(c.offset, c.length, null);
886                                 c.doit = false;
887                                 c.length = 0;
888                         }
889
890                 } catch (BadLocationException e) {
891                         WebUI.log(e);
892                 }
893
894                 try {
895                         int line = document.getLineOfOffset(c.offset);
896                         int lineOffset = document.getLineOffset(line);
897                         String prefix = jdocExtractLinePrefix(document, line);
898                         boolean always = c.offset > lineOffset
899                                         && c.offset <= lineOffset + prefix.length();
900                         int[] caretOffset = { c.offset };
901                         jdocWrapParagraphFromLine(document, document
902                                         .getLineOfOffset(c.offset), caretOffset, always);
903                         c.offset = caretOffset[0];
904
905                 } catch (BadLocationException e) {
906                         WebUI.log(e);
907                 }
908         }
909
910         /**
911          * Returns the compilation unit of the CompilationUnitEditor invoking the
912          * AutoIndentStrategy, might return <code>null</code> on error.
913          */
914         private static ICompilationUnit getCompilationUnit() {
915
916                 IWorkbenchWindow window = PlatformUI.getWorkbench()
917                                 .getActiveWorkbenchWindow();
918                 if (window == null)
919                         return null;
920
921                 IWorkbenchPage page = window.getActivePage();
922                 if (page == null)
923                         return null;
924
925                 IEditorPart editor = page.getActiveEditor();
926                 if (editor == null)
927                         return null;
928
929                 IWorkingCopyManager manager = WebUI.getDefault()
930                                 .getWorkingCopyManager();
931                 ICompilationUnit unit = manager.getWorkingCopy(editor.getEditorInput());
932                 if (unit == null)
933                         return null;
934
935                 return unit;
936         }
937
938 }