Rename HTML editor to Smarty editor
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / PHPUnitEditor.java
1 package net.sourceforge.phpeclipse.phpeditor;
2
3 import java.text.MessageFormat;
4 import java.util.ArrayList;
5 import java.util.HashMap;
6 import java.util.Iterator;
7 import java.util.List;
8 import java.util.Map;
9
10 import net.sourceforge.phpdt.core.ICompilationUnit;
11 import net.sourceforge.phpdt.core.IJavaElement;
12 import net.sourceforge.phpdt.core.IJavaProject;
13 import net.sourceforge.phpdt.core.IMember;
14 import net.sourceforge.phpdt.core.ISourceRange;
15 import net.sourceforge.phpdt.core.ISourceReference;
16 import net.sourceforge.phpdt.core.JavaCore;
17 import net.sourceforge.phpdt.core.JavaModelException;
18 import net.sourceforge.phpdt.core.dom.CompilationUnit;
19 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
20 import net.sourceforge.phpdt.internal.ui.actions.AddBlockCommentAction;
21 import net.sourceforge.phpdt.internal.ui.actions.CompositeActionGroup;
22 import net.sourceforge.phpdt.internal.ui.actions.IndentAction;
23 import net.sourceforge.phpdt.internal.ui.actions.RemoveBlockCommentAction;
24 import net.sourceforge.phpdt.internal.ui.text.ContentAssistPreference;
25 import net.sourceforge.phpdt.internal.ui.text.IPHPPartitions;
26 import net.sourceforge.phpdt.internal.ui.text.PHPPairMatcher;
27 import net.sourceforge.phpdt.internal.ui.text.SmartBackspaceManager;
28 import net.sourceforge.phpdt.internal.ui.text.SmartSemicolonAutoEditStrategy;
29 import net.sourceforge.phpdt.internal.ui.text.comment.CommentFormattingContext;
30 import net.sourceforge.phpdt.internal.ui.text.java.IJavaReconcilingListener;
31 import net.sourceforge.phpdt.internal.ui.text.link.LinkedPositionManager;
32 import net.sourceforge.phpdt.internal.ui.text.link.LinkedPositionUI;
33 import net.sourceforge.phpdt.internal.ui.text.link.LinkedPositionUI.ExitFlags;
34 import net.sourceforge.phpdt.ui.IWorkingCopyManager;
35 import net.sourceforge.phpdt.ui.PreferenceConstants;
36 import net.sourceforge.phpdt.ui.actions.GenerateActionGroup;
37 import net.sourceforge.phpdt.ui.text.JavaTextTools;
38 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
39 import net.sourceforge.phpeclipse.phpeditor.actions.RTrimAction;
40 import net.sourceforge.phpeclipse.ui.editor.ShowExternalPreviewAction;
41
42 import org.eclipse.core.internal.runtime.ListenerList;
43 import org.eclipse.core.resources.IFile;
44 import org.eclipse.core.resources.IWorkspaceRoot;
45 import org.eclipse.core.resources.ResourcesPlugin;
46 import org.eclipse.core.runtime.CoreException;
47 import org.eclipse.core.runtime.IPath;
48 import org.eclipse.core.runtime.IProgressMonitor;
49 import org.eclipse.core.runtime.IStatus;
50 import org.eclipse.core.runtime.Preferences;
51 import org.eclipse.jface.action.Action;
52 import org.eclipse.jface.action.IAction;
53 import org.eclipse.jface.action.IMenuManager;
54 import org.eclipse.jface.dialogs.ErrorDialog;
55 import org.eclipse.jface.dialogs.IMessageProvider;
56 import org.eclipse.jface.dialogs.MessageDialog;
57 import org.eclipse.jface.preference.IPreferenceStore;
58 import org.eclipse.jface.preference.PreferenceConverter;
59 import org.eclipse.jface.text.BadLocationException;
60 import org.eclipse.jface.text.DocumentCommand;
61 import org.eclipse.jface.text.IAutoEditStrategy;
62 import org.eclipse.jface.text.IDocument;
63 import org.eclipse.jface.text.ILineTracker;
64 import org.eclipse.jface.text.IRegion;
65 import org.eclipse.jface.text.ITextOperationTarget;
66 import org.eclipse.jface.text.ITextViewerExtension;
67 import org.eclipse.jface.text.ITypedRegion;
68 import org.eclipse.jface.text.IWidgetTokenKeeper;
69 import org.eclipse.jface.text.contentassist.ContentAssistant;
70 import org.eclipse.jface.text.contentassist.IContentAssistant;
71 import org.eclipse.jface.text.formatter.FormattingContextProperties;
72 import org.eclipse.jface.text.formatter.IFormattingContext;
73 import org.eclipse.jface.text.source.IOverviewRuler;
74 import org.eclipse.jface.text.source.ISourceViewer;
75 import org.eclipse.jface.text.source.IVerticalRuler;
76 import org.eclipse.jface.text.source.SourceViewerConfiguration;
77 import org.eclipse.jface.util.PropertyChangeEvent;
78 import org.eclipse.jface.window.Window;
79 import org.eclipse.swt.SWT;
80 import org.eclipse.swt.custom.VerifyKeyListener;
81 import org.eclipse.swt.events.VerifyEvent;
82 import org.eclipse.swt.graphics.Color;
83 import org.eclipse.swt.graphics.Point;
84 import org.eclipse.swt.graphics.RGB;
85 import org.eclipse.swt.widgets.Composite;
86 import org.eclipse.swt.widgets.Display;
87 import org.eclipse.swt.widgets.Shell;
88 import org.eclipse.ui.IEditorInput;
89 import org.eclipse.ui.IEditorPart;
90 import org.eclipse.ui.IFileEditorInput;
91 import org.eclipse.ui.IWorkbenchPage;
92 import org.eclipse.ui.IWorkbenchWindow;
93 import org.eclipse.ui.actions.ActionContext;
94 import org.eclipse.ui.actions.ActionGroup;
95 import org.eclipse.ui.dialogs.SaveAsDialog;
96 import org.eclipse.ui.editors.text.IStorageDocumentProvider;
97 import org.eclipse.ui.help.WorkbenchHelp;
98 import org.eclipse.ui.part.FileEditorInput;
99 import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
100 import org.eclipse.ui.texteditor.ContentAssistAction;
101 import org.eclipse.ui.texteditor.IDocumentProvider;
102 import org.eclipse.ui.texteditor.ITextEditorActionConstants;
103 import org.eclipse.ui.texteditor.TextOperationAction;
104
105 /*******************************************************************************
106  * Copyright (c) 2000, 2002 IBM Corp. and others. All rights reserved. This
107  * program and the accompanying materials are made available under the terms of
108  * the Common Public License v1.0 which accompanies this distribution, and is
109  * available at http://www.eclipse.org/legal/cpl-v10.html
110  *
111  * Contributors: IBM Corporation - Initial implementation
112  * www.phpeclipse.de
113  ******************************************************************************/
114 /**
115  * PHP specific text editor.
116  */
117 public class PHPUnitEditor extends PHPEditor { //implements
118   // IJavaReconcilingListener {
119   interface ITextConverter {
120     void customizeDocumentCommand(IDocument document, DocumentCommand command);
121   };
122
123   //  class AdaptedSourceViewer extends JavaSourceViewer {
124   //    private List fTextConverters;
125   //
126   //    private boolean fIgnoreTextConverters = false;
127   //
128   //    // private JavaCorrectionAssistant fCorrectionAssistant;
129   //    public AdaptedSourceViewer(Composite parent, IVerticalRuler verticalRuler,
130   //        IOverviewRuler overviewRuler, boolean showAnnotationsOverview,
131   //        int styles, IPreferenceStore store) {
132   //      super(parent, verticalRuler, overviewRuler, showAnnotationsOverview,
133   //          styles, store);
134   //    }
135   //
136   //    // public AdaptedSourceViewer(Composite parent,
137   //    // IVerticalRuler verticalRuler, IOverviewRuler overviewRuler,
138   //    // boolean showAnnotationsOverview, int styles) {
139   //    // super(parent, verticalRuler, overviewRuler,
140   //    // showAnnotationsOverview, styles);
141   //    // }
142   //    public IContentAssistant getContentAssistant() {
143   //      return fContentAssistant;
144   //    }
145   //
146   //    /*
147   //     * @see ITextOperationTarget#doOperation(int)
148   //     */
149   //    public void doOperation(int operation) {
150   //      if (getTextWidget() == null)
151   //        return;
152   //      switch (operation) {
153   //      case CONTENTASSIST_PROPOSALS:
154   //        String msg = fContentAssistant.showPossibleCompletions();
155   //        setStatusLineErrorMessage(msg);
156   //        return;
157   //      // case CORRECTIONASSIST_PROPOSALS:
158   //      // fCorrectionAssistant.showPossibleCompletions();
159   //      // return;
160   //      case UNDO:
161   //        fIgnoreTextConverters = true;
162   //        break;
163   //      case REDO:
164   //        fIgnoreTextConverters = true;
165   //        break;
166   //      }
167   //      super.doOperation(operation);
168   //    }
169   //
170   //    /*
171   //     * @see ITextOperationTarget#canDoOperation(int)
172   //     */
173   //    public boolean canDoOperation(int operation) {
174   //      // if (operation == CORRECTIONASSIST_PROPOSALS)
175   //      // return isEditable();
176   //      return super.canDoOperation(operation);
177   //    }
178   //
179   //    /*
180   //     * @see TextViewer#handleDispose()
181   //     */
182   //    protected void handleDispose() {
183   //      // if (fCorrectionAssistant != null) {
184   //      // fCorrectionAssistant.uninstall();
185   //      // fCorrectionAssistant= null;
186   //      // }
187   //      super.handleDispose();
188   //    }
189   //
190   //    public void insertTextConverter(ITextConverter textConverter, int index) {
191   //      throw new UnsupportedOperationException();
192   //    }
193   //
194   //    public void addTextConverter(ITextConverter textConverter) {
195   //      if (fTextConverters == null) {
196   //        fTextConverters = new ArrayList(1);
197   //        fTextConverters.add(textConverter);
198   //      } else if (!fTextConverters.contains(textConverter))
199   //        fTextConverters.add(textConverter);
200   //    }
201   //
202   //    public void removeTextConverter(ITextConverter textConverter) {
203   //      if (fTextConverters != null) {
204   //        fTextConverters.remove(textConverter);
205   //        if (fTextConverters.size() == 0)
206   //          fTextConverters = null;
207   //      }
208   //    }
209   //
210   //    /*
211   //     * @see TextViewer#customizeDocumentCommand(DocumentCommand)
212   //     */
213   //    protected void customizeDocumentCommand(DocumentCommand command) {
214   //      super.customizeDocumentCommand(command);
215   //      if (!fIgnoreTextConverters && fTextConverters != null) {
216   //        for (Iterator e = fTextConverters.iterator(); e.hasNext();)
217   //          ((ITextConverter) e.next()).customizeDocumentCommand(getDocument(),
218   //              command);
219   //      }
220   //      fIgnoreTextConverters = false;
221   //    }
222   //
223   //    // http://dev.eclipse.org/bugs/show_bug.cgi?id=19270
224   //    public void updateIndentationPrefixes() {
225   //      SourceViewerConfiguration configuration = getSourceViewerConfiguration();
226   //      String[] types = configuration.getConfiguredContentTypes(this);
227   //      for (int i = 0; i < types.length; i++) {
228   //        String[] prefixes = configuration.getIndentPrefixes(this, types[i]);
229   //        if (prefixes != null && prefixes.length > 0)
230   //          setIndentPrefixes(prefixes, types[i]);
231   //      }
232   //    }
233   //
234   //    /*
235   //     * @see IWidgetTokenOwner#requestWidgetToken(IWidgetTokenKeeper)
236   //     */
237   //    public boolean requestWidgetToken(IWidgetTokenKeeper requester) {
238   //      if (WorkbenchHelp.isContextHelpDisplayed())
239   //        return false;
240   //      return super.requestWidgetToken(requester);
241   //    }
242   //
243   //// /*
244   //// * @see org.eclipse.jface.text.source.ISourceViewer#configure(org.eclipse.jface.text.source.SourceViewerConfiguration)
245   //// */
246   //// public void configure(SourceViewerConfiguration configuration) {
247   //// super.configure(configuration);
248   //// // fCorrectionAssistant= new
249   //// // JavaCorrectionAssistant(CompilationUnitEditor.this);
250   //// // fCorrectionAssistant.install(this);
251   //// //TODO install SmartBracesAutoEditStrategy
252   //// // prependAutoEditStrategy(new SmartBracesAutoEditStrategy(this),
253   //// // IDocument.DEFAULT_CONTENT_TYPE);
254   //// }
255   //    public void configure(SourceViewerConfiguration configuration) {
256   //            super.configure(configuration);
257   //// fCorrectionAssistant= new JavaCorrectionAssistant(CompilationUnitEditor.this);
258   //// fCorrectionAssistant.install(this);
259   //            IAutoEditStrategy smartSemi= new SmartSemicolonAutoEditStrategy(IPHPPartitions.PHP_PARTITIONING);
260   //            prependAutoEditStrategy(smartSemi, IDocument.DEFAULT_CONTENT_TYPE);
261   //            prependAutoEditStrategy(smartSemi, IPHPPartitions.PHP_STRING_DQ);
262   //            prependAutoEditStrategy(smartSemi, IPHPPartitions.PHP_STRING_SQ);
263   //// prependAutoEditStrategy(smartSemi, IPHPPartitions.JAVA_CHARACTER);
264   //    }
265   //  };
266   class AdaptedSourceViewer extends JavaSourceViewer {
267
268     private List fTextConverters;
269
270     private boolean fIgnoreTextConverters = false;
271
272     //    private JavaCorrectionAssistant fCorrectionAssistant;
273
274     public AdaptedSourceViewer(Composite parent, IVerticalRuler verticalRuler, IOverviewRuler overviewRuler,
275         boolean showAnnotationsOverview, int styles, IPreferenceStore store) {
276       super(parent, verticalRuler, overviewRuler, showAnnotationsOverview, styles, store);
277     }
278
279     public IContentAssistant getContentAssistant() {
280       return fContentAssistant;
281     }
282
283     /*
284      * @see ITextOperationTarget#doOperation(int)
285      */
286     public void doOperation(int operation) {
287
288       if (getTextWidget() == null)
289         return;
290
291       switch (operation) {
292       case CONTENTASSIST_PROPOSALS:
293         String msg = fContentAssistant.showPossibleCompletions();
294         setStatusLineErrorMessage(msg);
295         return;
296       //      case CORRECTIONASSIST_PROPOSALS:
297       //        msg = fCorrectionAssistant.showPossibleCompletions();
298       //        setStatusLineErrorMessage(msg);
299       //        return;
300       case UNDO:
301         fIgnoreTextConverters = true;
302         super.doOperation(operation);
303         fIgnoreTextConverters = false;
304         return;
305       case REDO:
306         fIgnoreTextConverters = true;
307         super.doOperation(operation);
308         fIgnoreTextConverters = false;
309         return;
310       }
311
312       super.doOperation(operation);
313     }
314
315     /*
316      * @see ITextOperationTarget#canDoOperation(int)
317      */
318     public boolean canDoOperation(int operation) {
319       //      if (operation == CORRECTIONASSIST_PROPOSALS)
320       //        return isEditable();
321
322       return super.canDoOperation(operation);
323     }
324
325     /*
326      * @see org.eclipse.jface.text.source.ISourceViewerExtension2#unconfigure()
327      * @since 3.0
328      */
329     public void unconfigure() {
330       //      if (fCorrectionAssistant != null) {
331       //        fCorrectionAssistant.uninstall();
332       //        fCorrectionAssistant = null;
333       //      }
334       super.unconfigure();
335     }
336
337     public void insertTextConverter(ITextConverter textConverter, int index) {
338       throw new UnsupportedOperationException();
339     }
340
341     public void addTextConverter(ITextConverter textConverter) {
342       if (fTextConverters == null) {
343         fTextConverters = new ArrayList(1);
344         fTextConverters.add(textConverter);
345       } else if (!fTextConverters.contains(textConverter))
346         fTextConverters.add(textConverter);
347     }
348
349     public void removeTextConverter(ITextConverter textConverter) {
350       if (fTextConverters != null) {
351         fTextConverters.remove(textConverter);
352         if (fTextConverters.size() == 0)
353           fTextConverters = null;
354       }
355     }
356
357     /*
358      * @see TextViewer#customizeDocumentCommand(DocumentCommand)
359      */
360     protected void customizeDocumentCommand(DocumentCommand command) {
361       super.customizeDocumentCommand(command);
362       if (!fIgnoreTextConverters && fTextConverters != null) {
363         for (Iterator e = fTextConverters.iterator(); e.hasNext();)
364           ((ITextConverter) e.next()).customizeDocumentCommand(getDocument(), command);
365       }
366     }
367
368     // http://dev.eclipse.org/bugs/show_bug.cgi?id=19270
369     public void updateIndentationPrefixes() {
370       SourceViewerConfiguration configuration = getSourceViewerConfiguration();
371       String[] types = configuration.getConfiguredContentTypes(this);
372       for (int i = 0; i < types.length; i++) {
373         String[] prefixes = configuration.getIndentPrefixes(this, types[i]);
374         if (prefixes != null && prefixes.length > 0)
375           setIndentPrefixes(prefixes, types[i]);
376       }
377     }
378
379     /*
380      * @see IWidgetTokenOwner#requestWidgetToken(IWidgetTokenKeeper)
381      */
382     public boolean requestWidgetToken(IWidgetTokenKeeper requester) {
383       if (WorkbenchHelp.isContextHelpDisplayed())
384         return false;
385       return super.requestWidgetToken(requester);
386     }
387
388     /*
389      * @see IWidgetTokenOwnerExtension#requestWidgetToken(IWidgetTokenKeeper, int)
390      * @since 3.0
391      */
392     public boolean requestWidgetToken(IWidgetTokenKeeper requester, int priority) {
393       if (WorkbenchHelp.isContextHelpDisplayed())
394         return false;
395       return super.requestWidgetToken(requester, priority);
396     }
397
398     /*
399      * @see org.eclipse.jface.text.source.ISourceViewer#configure(org.eclipse.jface.text.source.SourceViewerConfiguration)
400      */
401     public void configure(SourceViewerConfiguration configuration) {
402       super.configure(configuration);
403       //      fCorrectionAssistant = new JavaCorrectionAssistant(CompilationUnitEditor.this);
404       //      fCorrectionAssistant.install(this);
405       IAutoEditStrategy smartSemi = new SmartSemicolonAutoEditStrategy(IPHPPartitions.PHP_PARTITIONING);
406       prependAutoEditStrategy(smartSemi, IDocument.DEFAULT_CONTENT_TYPE);
407       prependAutoEditStrategy(smartSemi, IPHPPartitions.PHP_STRING_DQ);
408       prependAutoEditStrategy(smartSemi, IPHPPartitions.PHP_STRING_SQ);
409       prependAutoEditStrategy(smartSemi, IPHPPartitions.PHP_STRING_HEREDOC);
410     }
411
412     /*
413      * @see org.eclipse.jface.text.source.SourceViewer#createFormattingContext()
414      * @since 3.0
415      */
416     public IFormattingContext createFormattingContext() {
417       IFormattingContext context = new CommentFormattingContext();
418
419       Map preferences;
420       IJavaElement inputJavaElement = getInputJavaElement();
421       IJavaProject javaProject = inputJavaElement != null ? inputJavaElement.getJavaProject() : null;
422       if (javaProject == null)
423         preferences = new HashMap(JavaCore.getOptions());
424       else
425         preferences = new HashMap(javaProject.getOptions(true));
426
427       context.storeToMap(PreferenceConstants.getPreferenceStore(), preferences, false);
428       context.setProperty(FormattingContextProperties.CONTEXT_PREFERENCES, preferences);
429
430       return context;
431     }
432   }
433
434   /**
435    * Remembers data related to the current selection to be able to restore it later.
436    *
437    * @since 3.0
438    */
439   private class RememberedSelection {
440     /** The remembered selection start. */
441     private RememberedOffset fStartOffset = new RememberedOffset();
442
443     /** The remembered selection end. */
444     private RememberedOffset fEndOffset = new RememberedOffset();
445
446     /**
447      * Remember current selection.
448      */
449     public void remember() {
450       /*
451        * https://bugs.eclipse.org/bugs/show_bug.cgi?id=52257 This method may be called inside an async call posted to the UI thread,
452        * so protect against intermediate disposal of the editor.
453        */
454       ISourceViewer viewer = getSourceViewer();
455       if (viewer != null) {
456         IRegion selection = getSignedSelection(viewer);
457         int startOffset = selection.getOffset();
458         int endOffset = startOffset + selection.getLength();
459
460         fStartOffset.setOffset(startOffset);
461         fEndOffset.setOffset(endOffset);
462       }
463     }
464
465     /**
466      * Restore remembered selection.
467      */
468     public void restore() {
469       /*
470        * https://bugs.eclipse.org/bugs/show_bug.cgi?id=52257 This method may be called inside an async call posted to the UI thread,
471        * so protect against intermediate disposal of the editor.
472        */
473       if (getSourceViewer() == null)
474         return;
475
476       try {
477
478         int startOffset, endOffset;
479         int revealStartOffset, revealEndOffset;
480         if (showsHighlightRangeOnly()) {
481           IJavaElement newStartElement = fStartOffset.getElement();
482           startOffset = fStartOffset.getRememberedOffset(newStartElement);
483           revealStartOffset = fStartOffset.getRevealOffset(newStartElement, startOffset);
484           if (revealStartOffset == -1)
485             startOffset = -1;
486
487           IJavaElement newEndElement = fEndOffset.getElement();
488           endOffset = fEndOffset.getRememberedOffset(newEndElement);
489           revealEndOffset = fEndOffset.getRevealOffset(newEndElement, endOffset);
490           if (revealEndOffset == -1)
491             endOffset = -1;
492         } else {
493           startOffset = fStartOffset.getOffset();
494           revealStartOffset = startOffset;
495           endOffset = fEndOffset.getOffset();
496           revealEndOffset = endOffset;
497         }
498
499         if (startOffset == -1) {
500           startOffset = endOffset; // fallback to caret offset
501           revealStartOffset = revealEndOffset;
502         }
503
504         if (endOffset == -1) {
505           endOffset = startOffset; // fallback to other offset
506           revealEndOffset = revealStartOffset;
507         }
508
509         IJavaElement element;
510         if (endOffset == -1) {
511           // fallback to element selection
512           element = fEndOffset.getElement();
513           if (element == null)
514             element = fStartOffset.getElement();
515           if (element != null)
516             setSelection(element);
517           return;
518         }
519
520         if (isValidSelection(revealStartOffset, revealEndOffset - revealStartOffset)
521             && isValidSelection(startOffset, endOffset - startOffset))
522           selectAndReveal(startOffset, endOffset - startOffset, revealStartOffset, revealEndOffset - revealStartOffset);
523       } finally {
524         fStartOffset.clear();
525         fEndOffset.clear();
526       }
527     }
528
529     private boolean isValidSelection(int offset, int length) {
530       IDocumentProvider provider = getDocumentProvider();
531       if (provider != null) {
532         IDocument document = provider.getDocument(getEditorInput());
533         if (document != null) {
534           int end = offset + length;
535           int documentLength = document.getLength();
536           return 0 <= offset && offset <= documentLength && 0 <= end && end <= documentLength;
537         }
538       }
539       return false;
540     }
541
542   }
543
544   /**
545    * Remembers additional data for a given offset to be able restore it later.
546    *
547    * @since 3.0
548    */
549   private class RememberedOffset {
550     /** Remembered line for the given offset */
551     private int fLine;
552
553     /** Remembered column for the given offset */
554     private int fColumn;
555
556     /** Remembered Java element for the given offset */
557     private IJavaElement fElement;
558
559     /** Remembered Java element line for the given offset */
560     private int fElementLine;
561
562     /**
563      * Store visual properties of the given offset.
564      *
565      * @param offset
566      *          Offset in the document
567      */
568     public void setOffset(int offset) {
569       try {
570         IDocument document = getSourceViewer().getDocument();
571         fLine = document.getLineOfOffset(offset);
572         fColumn = offset - document.getLineOffset(fLine);
573         fElement = getElementAt(offset, true);
574
575         fElementLine = -1;
576         if (fElement instanceof IMember) {
577           ISourceRange range = ((IMember) fElement).getNameRange();
578           if (range != null)
579             fElementLine = document.getLineOfOffset(range.getOffset());
580         }
581         if (fElementLine == -1)
582           fElementLine = document.getLineOfOffset(getOffset(fElement));
583       } catch (BadLocationException e) {
584         // should not happen
585         PHPeclipsePlugin.log(e);
586         clear();
587       } catch (JavaModelException e) {
588         // should not happen
589         PHPeclipsePlugin.log(e.getStatus());
590         clear();
591       }
592     }
593
594     /**
595      * Return offset recomputed from stored visual properties.
596      *
597      * @return Offset in the document
598      */
599     public int getOffset() {
600       IJavaElement newElement = getElement();
601
602       int offset = getRememberedOffset(newElement);
603
604       if (offset != -1 && !containsOffset(newElement, offset) && (offset == 0 || !containsOffset(newElement, offset - 1)))
605         return -1;
606
607       return offset;
608     }
609
610     /**
611      * Return offset recomputed from stored visual properties.
612      *
613      * @param newElement
614      *          Enclosing element
615      * @return Offset in the document
616      */
617     public int getRememberedOffset(IJavaElement newElement) {
618       try {
619         if (newElement == null)
620           return -1;
621
622         IDocument document = getSourceViewer().getDocument();
623         int newElementLine = -1;
624         if (newElement instanceof IMember) {
625           ISourceRange range = ((IMember) newElement).getNameRange();
626           if (range != null)
627             newElementLine = document.getLineOfOffset(range.getOffset());
628         }
629         if (newElementLine == -1)
630           newElementLine = document.getLineOfOffset(getOffset(newElement));
631         if (newElementLine == -1)
632           return -1;
633
634         int newLine = fLine + newElementLine - fElementLine;
635         if (newLine < 0 || newLine >= document.getNumberOfLines())
636           return -1;
637         int maxColumn = document.getLineLength(newLine);
638         String lineDelimiter = document.getLineDelimiter(newLine);
639         if (lineDelimiter != null)
640           maxColumn = maxColumn - lineDelimiter.length();
641         int offset;
642         if (fColumn > maxColumn)
643           offset = document.getLineOffset(newLine) + maxColumn;
644         else
645           offset = document.getLineOffset(newLine) + fColumn;
646
647         return offset;
648       } catch (BadLocationException e) {
649         // should not happen
650         PHPeclipsePlugin.log(e);
651         return -1;
652       } catch (JavaModelException e) {
653         // should not happen
654         PHPeclipsePlugin.log(e.getStatus());
655         return -1;
656       }
657     }
658
659     /**
660      * Returns the offset used to reveal the given element based on the given selection offset.
661      *
662      * @param element
663      *          the element
664      * @param offset
665      *          the selection offset
666      * @return the offset to reveal the given element based on the given selection offset
667      */
668     public int getRevealOffset(IJavaElement element, int offset) {
669       if (element == null || offset == -1)
670         return -1;
671
672       if (containsOffset(element, offset)) {
673         if (offset > 0) {
674           IJavaElement alternateElement = getElementAt(offset, false);
675           if (element.getHandleIdentifier().equals(alternateElement.getParent().getHandleIdentifier()))
676             return offset - 1; // Solves test case 2 from https://bugs.eclipse.org/bugs/show_bug.cgi?id=47727#c3
677         }
678         return offset;
679       } else if (offset > 0 && containsOffset(element, offset - 1))
680         return offset - 1; // Solves test case 1 from https://bugs.eclipse.org/bugs/show_bug.cgi?id=47727#c3
681
682       return -1;
683     }
684
685     /**
686      * Return Java element recomputed from stored visual properties.
687      *
688      * @return Java element
689      */
690     public IJavaElement getElement() {
691       if (fElement == null)
692         return null;
693
694       return findElement(fElement);
695     }
696
697     /**
698      * Clears the stored position
699      */
700     public void clear() {
701       fLine = -1;
702       fColumn = -1;
703       fElement = null;
704       fElementLine = -1;
705     }
706
707     /**
708      * Does the given Java element contain the given offset?
709      *
710      * @param element
711      *          Java element
712      * @param offset
713      *          Offset
714      * @return <code>true</code> iff the Java element contains the offset
715      */
716     private boolean containsOffset(IJavaElement element, int offset) {
717       int elementOffset = getOffset(element);
718       int elementLength = getLength(element);
719       return (elementOffset > -1 && elementLength > -1) ? (offset >= elementOffset && offset < elementOffset + elementLength)
720           : false;
721     }
722
723     /**
724      * Returns the offset of the given Java element.
725      *
726      * @param element
727      *          Java element
728      * @return Offset of the given Java element
729      */
730     private int getOffset(IJavaElement element) {
731       if (element instanceof ISourceReference) {
732         ISourceReference sr = (ISourceReference) element;
733         try {
734           ISourceRange srcRange = sr.getSourceRange();
735           if (srcRange != null)
736             return srcRange.getOffset();
737         } catch (JavaModelException e) {
738         }
739       }
740       return -1;
741     }
742
743     /**
744      * Returns the length of the given Java element.
745      *
746      * @param element
747      *          Java element
748      * @return Length of the given Java element
749      */
750     private int getLength(IJavaElement element) {
751       if (element instanceof ISourceReference) {
752         ISourceReference sr = (ISourceReference) element;
753         try {
754           ISourceRange srcRange = sr.getSourceRange();
755           if (srcRange != null)
756             return srcRange.getLength();
757         } catch (JavaModelException e) {
758         }
759       }
760       return -1;
761     }
762
763     /**
764      * Returns the updated java element for the old java element.
765      *
766      * @param element
767      *          Old Java element
768      * @return Updated Java element
769      */
770     private IJavaElement findElement(IJavaElement element) {
771
772       if (element == null)
773         return null;
774
775       IWorkingCopyManager manager = PHPeclipsePlugin.getDefault().getWorkingCopyManager();
776       ICompilationUnit unit = manager.getWorkingCopy(getEditorInput());
777
778       if (unit != null) {
779         try {
780
781           synchronized (unit) {
782             //                                          unit.reconcile(ICompilationUnit.NO_AST, false, null, null);
783             unit.reconcile();
784           }
785           IJavaElement[] findings = unit.findElements(element);
786           if (findings != null && findings.length > 0)
787             return findings[0];
788
789         } catch (JavaModelException x) {
790           PHPeclipsePlugin.log(x.getStatus());
791           // nothing found, be tolerant and go on
792         }
793       }
794
795       return null;
796     }
797
798   }
799
800   static class TabConverter implements ITextConverter {
801     private int fTabRatio;
802
803     private ILineTracker fLineTracker;
804
805     public TabConverter() {
806     }
807
808     public void setNumberOfSpacesPerTab(int ratio) {
809       fTabRatio = ratio;
810     }
811
812     public void setLineTracker(ILineTracker lineTracker) {
813       fLineTracker = lineTracker;
814     }
815
816     private int insertTabString(StringBuffer buffer, int offsetInLine) {
817       if (fTabRatio == 0)
818         return 0;
819       int remainder = offsetInLine % fTabRatio;
820       remainder = fTabRatio - remainder;
821       for (int i = 0; i < remainder; i++)
822         buffer.append(' ');
823       return remainder;
824     }
825
826     public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
827       String text = command.text;
828       if (text == null)
829         return;
830       int index = text.indexOf('\t');
831       if (index > -1) {
832         StringBuffer buffer = new StringBuffer();
833         fLineTracker.set(command.text);
834         int lines = fLineTracker.getNumberOfLines();
835         try {
836           for (int i = 0; i < lines; i++) {
837             int offset = fLineTracker.getLineOffset(i);
838             int endOffset = offset + fLineTracker.getLineLength(i);
839             String line = text.substring(offset, endOffset);
840             int position = 0;
841             if (i == 0) {
842               IRegion firstLine = document.getLineInformationOfOffset(command.offset);
843               position = command.offset - firstLine.getOffset();
844             }
845             int length = line.length();
846             for (int j = 0; j < length; j++) {
847               char c = line.charAt(j);
848               if (c == '\t') {
849                 position += insertTabString(buffer, position);
850               } else {
851                 buffer.append(c);
852                 ++position;
853               }
854             }
855           }
856           command.text = buffer.toString();
857         } catch (BadLocationException x) {
858         }
859       }
860     }
861   };
862
863   private static class ExitPolicy implements LinkedPositionUI.ExitPolicy {
864     final char fExitCharacter;
865
866     public ExitPolicy(char exitCharacter) {
867       fExitCharacter = exitCharacter;
868     }
869
870     /*
871      * @see org.phpeclipse.phpdt.internal.ui.text.link.LinkedPositionUI.ExitPolicy#doExit(org.phpeclipse.phpdt.internal.ui.text.link.LinkedPositionManager,
872      *      org.eclipse.swt.events.VerifyEvent, int, int)
873      */
874     public ExitFlags doExit(LinkedPositionManager manager, VerifyEvent event, int offset, int length) {
875       if (event.character == fExitCharacter) {
876         if (manager.anyPositionIncludes(offset, length))
877           return new ExitFlags(LinkedPositionUI.COMMIT | LinkedPositionUI.UPDATE_CARET, false);
878         else
879           return new ExitFlags(LinkedPositionUI.COMMIT, true);
880       }
881       switch (event.character) {
882       case '\b':
883         if (manager.getFirstPosition().length == 0)
884           return new ExitFlags(0, false);
885         else
886           return null;
887       case '\n':
888       case '\r':
889         return new ExitFlags(LinkedPositionUI.COMMIT, true);
890       default:
891         return null;
892       }
893     }
894   }
895
896   private static class BracketLevel {
897     int fOffset;
898
899     int fLength;
900
901     LinkedPositionManager fManager;
902
903     LinkedPositionUI fEditor;
904   };
905
906   private class BracketInserter implements VerifyKeyListener, LinkedPositionUI.ExitListener {
907     private boolean fCloseBracketsPHP = true;
908
909     private boolean fCloseStringsPHPDQ = true;
910
911     private boolean fCloseStringsPHPSQ = true;
912
913     private boolean fCloseBracketsHTML = true;
914
915     private boolean fCloseStringsHTML = true;
916
917     private int fOffset;
918
919     private int fLength;
920
921     public void setCloseBracketsPHPEnabled(boolean enabled) {
922       fCloseBracketsPHP = enabled;
923     }
924
925     public void setCloseStringsPHPDQEnabled(boolean enabled) {
926       fCloseStringsPHPDQ = enabled;
927     }
928
929     public void setCloseStringsPHPSQEnabled(boolean enabled) {
930       fCloseStringsPHPSQ = enabled;
931     }
932
933     public void setCloseBracketsHTMLEnabled(boolean enabled) {
934       fCloseBracketsHTML = enabled;
935     }
936
937     public void setCloseStringsHTMLEnabled(boolean enabled) {
938       fCloseStringsHTML = enabled;
939     }
940
941     private boolean hasIdentifierToTheRight(IDocument document, int offset) {
942       try {
943         int end = offset;
944         IRegion endLine = document.getLineInformationOfOffset(end);
945         int maxEnd = endLine.getOffset() + endLine.getLength();
946         while (end != maxEnd && Character.isWhitespace(document.getChar(end)))
947           ++end;
948         return end != maxEnd && Scanner.isPHPIdentifierPart(document.getChar(end));
949       } catch (BadLocationException e) {
950         // be conservative
951         return true;
952       }
953     }
954
955     private boolean hasIdentifierToTheLeft(IDocument document, int offset) {
956       try {
957         int start = offset;
958         IRegion startLine = document.getLineInformationOfOffset(start);
959         int minStart = startLine.getOffset();
960         while (start != minStart && Character.isWhitespace(document.getChar(start - 1)))
961           --start;
962         return start != minStart && Scanner.isPHPIdentifierPart(document.getChar(start - 1));
963       } catch (BadLocationException e) {
964         return true;
965       }
966     }
967
968     private boolean hasCharacterToTheRight(IDocument document, int offset, char character) {
969       try {
970         int end = offset;
971         IRegion endLine = document.getLineInformationOfOffset(end);
972         int maxEnd = endLine.getOffset() + endLine.getLength();
973         while (end != maxEnd && Character.isWhitespace(document.getChar(end)))
974           ++end;
975         return end != maxEnd && document.getChar(end) == character;
976       } catch (BadLocationException e) {
977         // be conservative
978         return true;
979       }
980     }
981
982     /*
983      * @see org.eclipse.swt.custom.VerifyKeyListener#verifyKey(org.eclipse.swt.events.VerifyEvent)
984      */
985     public void verifyKey(VerifyEvent event) {
986       if (!event.doit)
987         return;
988       final ISourceViewer sourceViewer = getSourceViewer();
989       IDocument document = sourceViewer.getDocument();
990       final Point selection = sourceViewer.getSelectedRange();
991       final int offset = selection.x;
992       final int length = selection.y;
993       try {
994         ITypedRegion partition = document.getPartition(offset);
995         String type = partition.getType();
996         if (type.equals(IPHPPartitions.PHP_PARTITIONING) || type.equals(IDocument.DEFAULT_CONTENT_TYPE)) {
997           // you will get IDocument.DEFAULT_CONTENT_TYPE for both PHP and HTML area
998           switch (event.character) {
999           case '(':
1000             if (hasCharacterToTheRight(document, offset + length, '('))
1001               return;
1002           // fall through
1003           case '[':
1004             if (!fCloseBracketsPHP)
1005               return;
1006             if (hasIdentifierToTheRight(document, offset + length))
1007               return;
1008           // fall through
1009           case '"':
1010             if (event.character == '"') {
1011               if (!fCloseStringsPHPDQ)
1012                 return;
1013               // changed for statements like echo "" print ""
1014               //    if (hasIdentifierToTheLeft(document, offset)
1015               // ||
1016               // hasIdentifierToTheRight(document, offset +
1017               // length))
1018               if (hasIdentifierToTheRight(document, offset + length))
1019                 return;
1020             }
1021             //     ITypedRegion partition=
1022             // document.getPartition(offset);
1023             //       if (!
1024             // IDocument.DEFAULT_CONTENT_TYPE.equals(partition.getType())
1025             // &&
1026             // (partition.getOffset() != offset))
1027             //         return;
1028             final char characterDQ = event.character;
1029             final char closingCharacterDQ = getPeerCharacter(characterDQ);
1030             final StringBuffer bufferDQ = new StringBuffer();
1031             bufferDQ.append(characterDQ);
1032             bufferDQ.append(closingCharacterDQ);
1033             document.replace(offset, length, bufferDQ.toString());
1034             LinkedPositionManager managerDQ = new LinkedPositionManager(document);
1035             managerDQ.addPosition(offset + 1, 0);
1036             fOffset = offset;
1037             fLength = 2;
1038             LinkedPositionUI editorDQ = new LinkedPositionUI(sourceViewer, managerDQ);
1039             editorDQ.setCancelListener(this);
1040             editorDQ.setExitPolicy(new ExitPolicy(closingCharacterDQ));
1041             editorDQ.setFinalCaretOffset(offset + 2);
1042             editorDQ.enter();
1043             IRegion newSelectionDQ = editorDQ.getSelectedRegion();
1044             sourceViewer.setSelectedRange(newSelectionDQ.getOffset(), newSelectionDQ.getLength());
1045             event.doit = false;
1046             break;
1047           //          fall through
1048           case '\'':
1049             if (event.character == '\'') {
1050               if (!fCloseStringsPHPSQ)
1051                 return;
1052               // changed for statements like echo "" print ""
1053               //    if (hasIdentifierToTheLeft(document, offset)
1054               // ||
1055               // hasIdentifierToTheRight(document, offset +
1056               // length))
1057               if (hasIdentifierToTheRight(document, offset + length))
1058                 return;
1059             }
1060             //     ITypedRegion partition=
1061             // document.getPartition(offset);
1062             //       if (!
1063             // IDocument.DEFAULT_CONTENT_TYPE.equals(partition.getType())
1064             // &&
1065             // (partition.getOffset() != offset))
1066             //         return;
1067             final char characterSQ = event.character;
1068             final char closingCharacterSQ = getPeerCharacter(characterSQ);
1069             final StringBuffer bufferSQ = new StringBuffer();
1070             bufferSQ.append(characterSQ);
1071             bufferSQ.append(closingCharacterSQ);
1072             document.replace(offset, length, bufferSQ.toString());
1073             LinkedPositionManager managerSQ = new LinkedPositionManager(document);
1074             managerSQ.addPosition(offset + 1, 0);
1075             fOffset = offset;
1076             fLength = 2;
1077             LinkedPositionUI editorSQ = new LinkedPositionUI(sourceViewer, managerSQ);
1078             editorSQ.setCancelListener(this);
1079             editorSQ.setExitPolicy(new ExitPolicy(closingCharacterSQ));
1080             editorSQ.setFinalCaretOffset(offset + 2);
1081             editorSQ.enter();
1082             IRegion newSelectionSQ = editorSQ.getSelectedRegion();
1083             sourceViewer.setSelectedRange(newSelectionSQ.getOffset(), newSelectionSQ.getLength());
1084             event.doit = false;
1085           }
1086         }
1087         //        } else if (type.equals(IPHPPartitions.HTML)) {
1088         //          switch (event.character) {
1089         //          case '(':
1090         //            if (hasCharacterToTheRight(document, offset + length, '('))
1091         //              return;
1092         //          // fall through
1093         //          case '[':
1094         //            if (!fCloseBracketsHTML)
1095         //              return;
1096         //            if (hasIdentifierToTheRight(document, offset + length))
1097         //              return;
1098         //          // fall through
1099         //          case '"':
1100         //            if (event.character == '"') {
1101         //              if (!fCloseStringsHTML)
1102         //                return;
1103         //              if (hasIdentifierToTheLeft(document, offset)
1104         //                  || hasIdentifierToTheRight(document, offset + length))
1105         //                return;
1106         //            }
1107         //            // ITypedRegion partition=
1108         //            // document.getPartition(offset);
1109         //            // if (!
1110         //            // IDocument.DEFAULT_CONTENT_TYPE.equals(partition.getType())
1111         //            // &&
1112         //            // (partition.getOffset() != offset))
1113         //            // return;
1114         //            final char character = event.character;
1115         //            final char closingCharacter = getPeerCharacter(character);
1116         //            final StringBuffer buffer = new StringBuffer();
1117         //            buffer.append(character);
1118         //            buffer.append(closingCharacter);
1119         //            document.replace(offset, length, buffer.toString());
1120         //            LinkedPositionManager manager = new LinkedPositionManager(document);
1121         //            manager.addPosition(offset + 1, 0);
1122         //            fOffset = offset;
1123         //            fLength = 2;
1124         //            LinkedPositionUI editor = new LinkedPositionUI(sourceViewer,
1125         //                manager);
1126         //            editor.setCancelListener(this);
1127         //            editor.setExitPolicy(new ExitPolicy(closingCharacter));
1128         //            editor.setFinalCaretOffset(offset + 2);
1129         //            editor.enter();
1130         //            IRegion newSelection = editor.getSelectedRegion();
1131         //            sourceViewer.setSelectedRange(newSelection.getOffset(),
1132         //                newSelection.getLength());
1133         //            event.doit = false;
1134         //          }
1135         //        }
1136       } catch (BadLocationException e) {
1137       }
1138     }
1139
1140     /*
1141      * @see org.phpeclipse.phpdt.internal.ui.text.link.LinkedPositionUI.ExitListener#exit(boolean)
1142      */
1143     public void exit(boolean accept) {
1144       if (accept)
1145         return;
1146       // remove brackets
1147       try {
1148         final ISourceViewer sourceViewer = getSourceViewer();
1149         IDocument document = sourceViewer.getDocument();
1150         document.replace(fOffset, fLength, null);
1151       } catch (BadLocationException e) {
1152       }
1153     }
1154   }
1155
1156   /** The editor's save policy */
1157   protected ISavePolicy fSavePolicy;
1158
1159   /**
1160    * Listener to annotation model changes that updates the error tick in the tab image
1161    */
1162   private JavaEditorErrorTickUpdater fJavaEditorErrorTickUpdater;
1163
1164   /** The editor's paint manager */
1165   //  private PaintManager fPaintManager;
1166   /** The editor's bracket painter */
1167   //  private BracketPainter fBracketPainter;
1168   /** The editor's bracket matcher */
1169   private PHPPairMatcher fBracketMatcher;
1170
1171   /** The editor's line painter */
1172   //  private LinePainter fLinePainter;
1173   /** The editor's print margin ruler painter */
1174   //  private PrintMarginPainter fPrintMarginPainter;
1175   /** The editor's problem painter */
1176   //  private ProblemPainter fProblemPainter;
1177   /** The editor's tab converter */
1178   private TabConverter fTabConverter;
1179
1180   /** History for structure select action */
1181   //private SelectionHistory fSelectionHistory;
1182   /** The preference property change listener for php core. */
1183   //  private IPropertyChangeListener fPropertyChangeListener = new
1184   // PropertyChangeListener();
1185   /** The remembered java element */
1186   private IJavaElement fRememberedElement;
1187
1188   /**
1189    * The remembered selection.
1190    *
1191    * @since 3.0
1192    */
1193   private RememberedSelection fRememberedSelection = new RememberedSelection();
1194
1195   /** The remembered php element offset */
1196   private int fRememberedElementOffset;
1197
1198   /** The bracket inserter. */
1199   private BracketInserter fBracketInserter = new BracketInserter();
1200
1201   /** The standard action groups added to the menu */
1202   private GenerateActionGroup fGenerateActionGroup;
1203
1204   private CompositeActionGroup fContextMenuGroup;
1205
1206   //  private class PropertyChangeListener implements IPropertyChangeListener {
1207   //    /*
1208   //     * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
1209   //     */
1210   //    public void
1211   // propertyChange(org.eclipse.core.runtime.Preferences.PropertyChangeEvent
1212   // event) {
1213   //      handlePreferencePropertyChanged(event);
1214   //    }
1215   //  }
1216   /* Preference key for code formatter tab size */
1217   private final static String CODE_FORMATTER_TAB_SIZE = JavaCore.FORMATTER_TAB_SIZE;
1218
1219   /** Preference key for matching brackets */
1220   //  private final static String MATCHING_BRACKETS = PreferenceConstants.EDITOR_MATCHING_BRACKETS;
1221   /** Preference key for matching brackets color */
1222   //  private final static String MATCHING_BRACKETS_COLOR = PreferenceConstants.EDITOR_MATCHING_BRACKETS_COLOR;
1223   /** Preference key for highlighting current line */
1224   //  private final static String CURRENT_LINE = PreferenceConstants.EDITOR_CURRENT_LINE;
1225   /** Preference key for highlight color of current line */
1226   //  private final static String CURRENT_LINE_COLOR = PreferenceConstants.EDITOR_CURRENT_LINE_COLOR;
1227   /** Preference key for showing print marging ruler */
1228   //  private final static String PRINT_MARGIN = PreferenceConstants.EDITOR_PRINT_MARGIN;
1229   /** Preference key for print margin ruler color */
1230   //  private final static String PRINT_MARGIN_COLOR = PreferenceConstants.EDITOR_PRINT_MARGIN_COLOR;
1231   /** Preference key for print margin ruler column */
1232   //  private final static String PRINT_MARGIN_COLUMN = PreferenceConstants.EDITOR_PRINT_MARGIN_COLUMN;
1233   /** Preference key for inserting spaces rather than tabs */
1234   private final static String SPACES_FOR_TABS = PreferenceConstants.EDITOR_SPACES_FOR_TABS;
1235
1236   /** Preference key for error indication */
1237   //  private final static String ERROR_INDICATION =
1238   // PreferenceConstants.EDITOR_PROBLEM_INDICATION;
1239   /** Preference key for error color */
1240   //  private final static String ERROR_INDICATION_COLOR =
1241   // PreferenceConstants.EDITOR_PROBLEM_INDICATION_COLOR;
1242   /** Preference key for warning indication */
1243   //  private final static String WARNING_INDICATION =
1244   // PreferenceConstants.EDITOR_WARNING_INDICATION;
1245   /** Preference key for warning color */
1246   //  private final static String WARNING_INDICATION_COLOR =
1247   // PreferenceConstants.EDITOR_WARNING_INDICATION_COLOR;
1248   /** Preference key for task indication */
1249   private final static String TASK_INDICATION = PreferenceConstants.EDITOR_TASK_INDICATION;
1250
1251   /** Preference key for task color */
1252   private final static String TASK_INDICATION_COLOR = PreferenceConstants.EDITOR_TASK_INDICATION_COLOR;
1253
1254   /** Preference key for bookmark indication */
1255   private final static String BOOKMARK_INDICATION = PreferenceConstants.EDITOR_BOOKMARK_INDICATION;
1256
1257   /** Preference key for bookmark color */
1258   private final static String BOOKMARK_INDICATION_COLOR = PreferenceConstants.EDITOR_BOOKMARK_INDICATION_COLOR;
1259
1260   /** Preference key for search result indication */
1261   private final static String SEARCH_RESULT_INDICATION = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION;
1262
1263   /** Preference key for search result color */
1264   private final static String SEARCH_RESULT_INDICATION_COLOR = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_COLOR;
1265
1266   /** Preference key for unknown annotation indication */
1267   private final static String UNKNOWN_INDICATION = PreferenceConstants.EDITOR_UNKNOWN_INDICATION;
1268
1269   /** Preference key for unknown annotation color */
1270   private final static String UNKNOWN_INDICATION_COLOR = PreferenceConstants.EDITOR_UNKNOWN_INDICATION_COLOR;
1271
1272   /** Preference key for linked position color */
1273   private final static String LINKED_POSITION_COLOR = PreferenceConstants.EDITOR_LINKED_POSITION_COLOR;
1274
1275   /** Preference key for shwoing the overview ruler */
1276   private final static String OVERVIEW_RULER = PreferenceConstants.EDITOR_OVERVIEW_RULER;
1277
1278   /** Preference key for error indication in overview ruler */
1279   private final static String ERROR_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_ERROR_INDICATION_IN_OVERVIEW_RULER;
1280
1281   /** Preference key for warning indication in overview ruler */
1282   private final static String WARNING_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_WARNING_INDICATION_IN_OVERVIEW_RULER;
1283
1284   /** Preference key for task indication in overview ruler */
1285   private final static String TASK_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_TASK_INDICATION_IN_OVERVIEW_RULER;
1286
1287   /** Preference key for bookmark indication in overview ruler */
1288   private final static String BOOKMARK_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_BOOKMARK_INDICATION_IN_OVERVIEW_RULER;
1289
1290   /** Preference key for search result indication in overview ruler */
1291   private final static String SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER;
1292
1293   /** Preference key for unknown annotation indication in overview ruler */
1294   private final static String UNKNOWN_INDICATION_IN_OVERVIEW_RULER = PreferenceConstants.EDITOR_UNKNOWN_INDICATION_IN_OVERVIEW_RULER;
1295
1296   /** Preference key for automatically closing double quoted strings */
1297   private final static String CLOSE_STRINGS_DQ_PHP = PreferenceConstants.EDITOR_CLOSE_STRINGS_DQ_PHP;
1298
1299   /** Preference key for automatically closing single quoted strings */
1300   private final static String CLOSE_STRINGS_SQ_PHP = PreferenceConstants.EDITOR_CLOSE_STRINGS_SQ_PHP;
1301
1302   /** Preference key for automatically wrapping Java strings */
1303   //  private final static String WRAP_STRINGS = PreferenceConstants.EDITOR_WRAP_STRINGS_DQ;
1304   /** Preference key for automatically closing brackets and parenthesis */
1305   private final static String CLOSE_BRACKETS_PHP = PreferenceConstants.EDITOR_CLOSE_BRACKETS_PHP;
1306
1307   /** Preference key for automatically closing phpdocs and comments */
1308   private final static String CLOSE_JAVADOCS = PreferenceConstants.EDITOR_CLOSE_JAVADOCS;
1309
1310   /** Preference key for automatically adding phpdoc tags */
1311   private final static String ADD_JAVADOC_TAGS = PreferenceConstants.EDITOR_ADD_JAVADOC_TAGS;
1312
1313   /** Preference key for automatically formatting phpdocs */
1314   //  private final static String FORMAT_JAVADOCS = PreferenceConstants.EDITOR_FORMAT_JAVADOCS;
1315   /** Preference key for automatically closing strings */
1316   private final static String CLOSE_STRINGS_HTML = PreferenceConstants.EDITOR_CLOSE_STRINGS_HTML;
1317
1318   /** Preference key for automatically closing brackets and parenthesis */
1319   private final static String CLOSE_BRACKETS_HTML = PreferenceConstants.EDITOR_CLOSE_BRACKETS_HTML;
1320
1321   /** Preference key for smart paste */
1322   private final static String SMART_PASTE = PreferenceConstants.EDITOR_SMART_PASTE;
1323
1324   //  private final static class AnnotationInfo {
1325   //    public String fColorPreference;
1326   //    public String fOverviewRulerPreference;
1327   //    public String fEditorPreference;
1328   //  };
1329   //  private final static Map ANNOTATION_MAP;
1330   //  static {
1331   //
1332   //    AnnotationInfo info;
1333   //    ANNOTATION_MAP = new HashMap();
1334   //
1335   //    info = new AnnotationInfo();
1336   //    info.fColorPreference = TASK_INDICATION_COLOR;
1337   //    info.fOverviewRulerPreference = TASK_INDICATION_IN_OVERVIEW_RULER;
1338   //    info.fEditorPreference = TASK_INDICATION;
1339   //    ANNOTATION_MAP.put(AnnotationType.TASK, info);
1340   //
1341   //    info = new AnnotationInfo();
1342   //    info.fColorPreference = ERROR_INDICATION_COLOR;
1343   //    info.fOverviewRulerPreference = ERROR_INDICATION_IN_OVERVIEW_RULER;
1344   //    info.fEditorPreference = ERROR_INDICATION;
1345   //    ANNOTATION_MAP.put(AnnotationType.ERROR, info);
1346   //
1347   //    info = new AnnotationInfo();
1348   //    info.fColorPreference = WARNING_INDICATION_COLOR;
1349   //    info.fOverviewRulerPreference = WARNING_INDICATION_IN_OVERVIEW_RULER;
1350   //    info.fEditorPreference = WARNING_INDICATION;
1351   //    ANNOTATION_MAP.put(AnnotationType.WARNING, info);
1352   //
1353   //    info = new AnnotationInfo();
1354   //    info.fColorPreference = BOOKMARK_INDICATION_COLOR;
1355   //    info.fOverviewRulerPreference = BOOKMARK_INDICATION_IN_OVERVIEW_RULER;
1356   //    info.fEditorPreference = BOOKMARK_INDICATION;
1357   //    ANNOTATION_MAP.put(AnnotationType.BOOKMARK, info);
1358   //
1359   //    info = new AnnotationInfo();
1360   //    info.fColorPreference = SEARCH_RESULT_INDICATION_COLOR;
1361   //    info.fOverviewRulerPreference =
1362   // SEARCH_RESULT_INDICATION_IN_OVERVIEW_RULER;
1363   //    info.fEditorPreference = SEARCH_RESULT_INDICATION;
1364   //    ANNOTATION_MAP.put(AnnotationType.SEARCH, info);
1365   //
1366   //    info = new AnnotationInfo();
1367   //    info.fColorPreference = UNKNOWN_INDICATION_COLOR;
1368   //    info.fOverviewRulerPreference = UNKNOWN_INDICATION_IN_OVERVIEW_RULER;
1369   //    info.fEditorPreference = UNKNOWN_INDICATION;
1370   //    ANNOTATION_MAP.put(AnnotationType.UNKNOWN, info);
1371   //  };
1372   //
1373   //  private final static AnnotationType[] ANNOTATION_LAYERS =
1374   //    new AnnotationType[] {
1375   //      AnnotationType.UNKNOWN,
1376   //      AnnotationType.BOOKMARK,
1377   //      AnnotationType.TASK,
1378   //      AnnotationType.SEARCH,
1379   //      AnnotationType.WARNING,
1380   //      AnnotationType.ERROR };
1381   /**
1382    * Creates a new php unit editor.
1383    */
1384
1385   /**
1386    * Reconciling listeners.
1387    *
1388    * @since 3.0
1389    */
1390   private ListenerList fReconcilingListeners = new ListenerList();
1391
1392   /**
1393    * Mutex for the reconciler. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=63898 for a description of the problem.
1394    * <p>
1395    * TODO remove once the underlying problem is solved.
1396    * </p>
1397    */
1398   private final Object fReconcilerLock = new Object();
1399
1400   public PHPUnitEditor() {
1401     super();
1402     setDocumentProvider(PHPeclipsePlugin.getDefault().getCompilationUnitDocumentProvider());
1403     setEditorContextMenuId("#PHPEditorContext"); //$NON-NLS-1$
1404     setRulerContextMenuId("#PHPRulerContext"); //$NON-NLS-1$
1405     setOutlinerContextMenuId("#PHPOutlinerContext"); //$NON-NLS-1$
1406     // don't set help contextId, we install our own help context
1407     fSavePolicy = null;
1408     fJavaEditorErrorTickUpdater = new JavaEditorErrorTickUpdater(this);
1409   }
1410
1411   /*
1412    * @see AbstractTextEditor#createActions()
1413    */
1414   protected void createActions() {
1415     super.createActions();
1416     Action action;
1417     //          Action action= new
1418     // TextOperationAction(PHPEditorMessages.getResourceBundle(),
1419     // "CorrectionAssistProposal.", this, CORRECTIONASSIST_PROPOSALS);
1420     // //$NON-NLS-1$
1421     //          action.setActionDefinitionId(PHPEditorActionDefinitionIds.CORRECTION_ASSIST_PROPOSALS);
1422     //          setAction("CorrectionAssistProposal", action); //$NON-NLS-1$
1423     //          markAsStateDependentAction("CorrectionAssistProposal", true);
1424     // //$NON-NLS-1$
1425     //// WorkbenchHelp.setHelp(action,
1426     // IJavaHelpContextIds.QUICK_FIX_ACTION);
1427     action = new ContentAssistAction(PHPEditorMessages.getResourceBundle(), "ContentAssistProposal.", this); //$NON-NLS-1$
1428     action.setActionDefinitionId(PHPEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
1429     setAction("ContentAssistProposal", action); //$NON-NLS-1$
1430     markAsStateDependentAction("ContentAssistProposal", true); //$NON-NLS-1$
1431     //          WorkbenchHelp.setHelp(action,
1432     // IJavaHelpContextIds.CONTENT_ASSIST_ACTION);
1433     //          action = new TextOperationAction(PHPEditorMessages.getResourceBundle(),
1434     //                          "ContentAssistContextInformation.", this,
1435     //                          ISourceViewer.CONTENTASSIST_CONTEXT_INFORMATION); //$NON-NLS-1$
1436     //          action
1437     //                          .setActionDefinitionId(PHPEditorActionDefinitionIds.CONTENT_ASSIST_CONTEXT_INFORMATION);
1438     //          setAction("ContentAssistContextInformation", action); //$NON-NLS-1$
1439     //          markAsStateDependentAction("ContentAssistContextInformation", true);
1440     // //$NON-NLS-1$
1441     //          WorkbenchHelp.setHelp(action,
1442     // IJavaHelpContextIds.PARAMETER_HINTS_ACTION);
1443     //          action= new
1444     // TextOperationAction(PHPEditorMessages.getResourceBundle(),
1445     // "ContentAssistCompletePrefix.", this, CONTENTASSIST_COMPLETE_PREFIX);
1446     // //$NON-NLS-1$
1447     //          action.setActionDefinitionId(PHPEditorActionDefinitionIds.CONTENT_ASSIST_COMPLETE_PREFIX);
1448     //          setAction("ContentAssistCompletePrefix", action); //$NON-NLS-1$
1449     //          markAsStateDependentAction("ContentAssistCompletePrefix", true);
1450     // //$NON-NLS-1$
1451     //// WorkbenchHelp.setHelp(action,
1452     // IJavaHelpContextIds.PARAMETER_HINTS_ACTION);
1453     action = new TextOperationAction(PHPEditorMessages.getResourceBundle(), "Comment.", this, ITextOperationTarget.PREFIX); //$NON-NLS-1$
1454     action.setActionDefinitionId(PHPEditorActionDefinitionIds.COMMENT);
1455     setAction("Comment", action); //$NON-NLS-1$
1456     markAsStateDependentAction("Comment", true); //$NON-NLS-1$
1457     //          WorkbenchHelp.setHelp(action, IJavaHelpContextIds.COMMENT_ACTION);
1458     action = new TextOperationAction(PHPEditorMessages.getResourceBundle(), "Uncomment.", this, ITextOperationTarget.STRIP_PREFIX); //$NON-NLS-1$
1459     action.setActionDefinitionId(PHPEditorActionDefinitionIds.UNCOMMENT);
1460     setAction("Uncomment", action); //$NON-NLS-1$
1461     markAsStateDependentAction("Uncomment", true); //$NON-NLS-1$
1462     //          WorkbenchHelp.setHelp(action, IJavaHelpContextIds.UNCOMMENT_ACTION);
1463
1464     action = new ToggleCommentAction(PHPEditorMessages.getResourceBundle(), "ToggleComment.", this); //$NON-NLS-1$
1465     action.setActionDefinitionId(PHPEditorActionDefinitionIds.TOGGLE_COMMENT);
1466     setAction("ToggleComment", action); //$NON-NLS-1$
1467     markAsStateDependentAction("ToggleComment", true); //$NON-NLS-1$
1468     //WorkbenchHelp.setHelp(action,
1469     // IJavaHelpContextIds.TOGGLE_COMMENT_ACTION);
1470     configureToggleCommentAction();
1471
1472     action = new TextOperationAction(PHPEditorMessages.getResourceBundle(), "Format.", this, ISourceViewer.FORMAT); //$NON-NLS-1$
1473     action.setActionDefinitionId(PHPEditorActionDefinitionIds.FORMAT);
1474     setAction("Format", action); //$NON-NLS-1$
1475     markAsStateDependentAction("Format", true); //$NON-NLS-1$
1476     markAsSelectionDependentAction("Format", true); //$NON-NLS-1$
1477     //          WorkbenchHelp.setHelp(action, IJavaHelpContextIds.FORMAT_ACTION);
1478
1479     //    action = new AddBlockCommentAction(PHPEditorMessages.getResourceBundle(),
1480     //        "AddBlockComment.", this); //$NON-NLS-1$
1481     //    action
1482     //        .setActionDefinitionId(PHPEditorActionDefinitionIds.ADD_BLOCK_COMMENT);
1483     //    setAction("AddBlockComment", action); //$NON-NLS-1$
1484     //    markAsStateDependentAction("AddBlockComment", true); //$NON-NLS-1$
1485     //    markAsSelectionDependentAction("AddBlockComment", true); //$NON-NLS-1$
1486     //    // WorkbenchHelp.setHelp(action,
1487     //    // IJavaHelpContextIds.ADD_BLOCK_COMMENT_ACTION);
1488     //    action = new RemoveBlockCommentAction(
1489     //        PHPEditorMessages.getResourceBundle(), "RemoveBlockComment.", this); //$NON-NLS-1$
1490     //    action
1491     //        .setActionDefinitionId(PHPEditorActionDefinitionIds.REMOVE_BLOCK_COMMENT);
1492     //    setAction("RemoveBlockComment", action); //$NON-NLS-1$
1493     //    markAsStateDependentAction("RemoveBlockComment", true); //$NON-NLS-1$
1494     //    markAsSelectionDependentAction("RemoveBlockComment", true); //$NON-NLS-1$
1495     //          WorkbenchHelp.setHelp(action,
1496     // IJavaHelpContextIds.ADD_BLOCK_COMMENT_ACTION);
1497     //          action= new IndentAction(PHPEditorMessages.getResourceBundle(),
1498     // "Indent.", this, false); //$NON-NLS-1$
1499     //          action.setActionDefinitionId(PHPEditorActionDefinitionIds.INDENT);
1500     //          setAction("Indent", action); //$NON-NLS-1$
1501     //          markAsStateDependentAction("Indent", true); //$NON-NLS-1$
1502     //          markAsSelectionDependentAction("Indent", true); //$NON-NLS-1$
1503     //// WorkbenchHelp.setHelp(action, IJavaHelpContextIds.INDENT_ACTION);
1504     //
1505     //          action= new IndentAction(PHPEditorMessages.getResourceBundle(),
1506     // "Indent.", this, true); //$NON-NLS-1$
1507     //          setAction("IndentOnTab", action); //$NON-NLS-1$
1508     //          markAsStateDependentAction("IndentOnTab", true); //$NON-NLS-1$
1509     //          markAsSelectionDependentAction("IndentOnTab", true); //$NON-NLS-1$
1510     //
1511
1512     action = new AddBlockCommentAction(PHPEditorMessages.getResourceBundle(), "AddBlockComment.", this); //$NON-NLS-1$
1513     action.setActionDefinitionId(PHPEditorActionDefinitionIds.ADD_BLOCK_COMMENT);
1514     setAction("AddBlockComment", action); //$NON-NLS-1$
1515     markAsStateDependentAction("AddBlockComment", true); //$NON-NLS-1$
1516     markAsSelectionDependentAction("AddBlockComment", true); //$NON-NLS-1$
1517     //  WorkbenchHelp.setHelp(action, IJavaHelpContextIds.ADD_BLOCK_COMMENT_ACTION);
1518
1519     action = new RemoveBlockCommentAction(PHPEditorMessages.getResourceBundle(), "RemoveBlockComment.", this); //$NON-NLS-1$
1520     action.setActionDefinitionId(PHPEditorActionDefinitionIds.REMOVE_BLOCK_COMMENT);
1521     setAction("RemoveBlockComment", action); //$NON-NLS-1$
1522     markAsStateDependentAction("RemoveBlockComment", true); //$NON-NLS-1$
1523     markAsSelectionDependentAction("RemoveBlockComment", true); //$NON-NLS-1$
1524     //  WorkbenchHelp.setHelp(action, IJavaHelpContextIds.REMOVE_BLOCK_COMMENT_ACTION);
1525
1526     //  action= new IndentAction(PHPEditorMessages.getResourceBundle(), "Indent.", this, false); //$NON-NLS-1$
1527     //  action.setActionDefinitionId(PHPEditorActionDefinitionIds.INDENT);
1528     //  setAction("Indent", action); //$NON-NLS-1$
1529     //  markAsStateDependentAction("Indent", true); //$NON-NLS-1$
1530     //  markAsSelectionDependentAction("Indent", true); //$NON-NLS-1$
1531     //// WorkbenchHelp.setHelp(action, IJavaHelpContextIds.INDENT_ACTION);
1532     //
1533     action = new IndentAction(PHPEditorMessages.getResourceBundle(), "Indent.", this, true); //$NON-NLS-1$
1534     setAction("IndentOnTab", action); //$NON-NLS-1$
1535     markAsStateDependentAction("IndentOnTab", true); //$NON-NLS-1$
1536     markAsSelectionDependentAction("IndentOnTab", true); //$NON-NLS-1$
1537
1538     if (getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_SMART_TAB)) {
1539       // don't replace Shift Right - have to make sure their enablement is
1540       // mutually exclusive
1541       //                        removeActionActivationCode(ITextEditorActionConstants.SHIFT_RIGHT);
1542       setActionActivationCode("IndentOnTab", '\t', -1, SWT.NONE); //$NON-NLS-1$
1543     }
1544     fGenerateActionGroup = new GenerateActionGroup(this, ITextEditorActionConstants.GROUP_EDIT);
1545     //    ActionGroup rg= new RefactorActionGroup(this, ITextEditorActionConstants.GROUP_EDIT);
1546
1547     //  fActionGroups.addGroup(rg);
1548     fActionGroups.addGroup(fGenerateActionGroup);
1549
1550     // We have to keep the context menu group separate to have better control over positioning
1551     fContextMenuGroup = new CompositeActionGroup(new ActionGroup[] { fGenerateActionGroup
1552     //          rg,
1553         //              new LocalHistoryActionGroup(this, ITextEditorActionConstants.GROUP_EDIT)
1554         });
1555
1556   }
1557
1558   /*
1559    * @see JavaEditor#getElementAt(int)
1560    */
1561   protected IJavaElement getElementAt(int offset) {
1562     return getElementAt(offset, true);
1563   }
1564
1565   /**
1566    * Returns the most narrow element including the given offset. If <code>reconcile</code> is <code>true</code> the editor's
1567    * input element is reconciled in advance. If it is <code>false</code> this method only returns a result if the editor's input
1568    * element does not need to be reconciled.
1569    *
1570    * @param offset
1571    *          the offset included by the retrieved element
1572    * @param reconcile
1573    *          <code>true</code> if working copy should be reconciled
1574    */
1575   protected IJavaElement getElementAt(int offset, boolean reconcile) {
1576     IWorkingCopyManager manager = PHPeclipsePlugin.getDefault().getWorkingCopyManager();
1577     ICompilationUnit unit = manager.getWorkingCopy(getEditorInput());
1578     if (unit != null) {
1579       try {
1580         if (reconcile) {
1581           synchronized (unit) {
1582             unit.reconcile();
1583           }
1584           return unit.getElementAt(offset);
1585         } else if (unit.isConsistent())
1586           return unit.getElementAt(offset);
1587       } catch (JavaModelException x) {
1588         PHPeclipsePlugin.log(x.getStatus());
1589         // nothing found, be tolerant and go on
1590       }
1591     }
1592     return null;
1593   }
1594
1595   /*
1596    * @see JavaEditor#getCorrespondingElement(IJavaElement)
1597    */
1598   protected IJavaElement getCorrespondingElement(IJavaElement element) {
1599     try {
1600       return EditorUtility.getWorkingCopy(element, true);
1601     } catch (JavaModelException x) {
1602       PHPeclipsePlugin.log(x.getStatus());
1603       // nothing found, be tolerant and go on
1604     }
1605     return null;
1606   }
1607
1608   public void createPartControl(Composite parent) {
1609     super.createPartControl(parent);
1610     //    fPaintManager = new PaintManager(getSourceViewer());
1611     LinePainter linePainter;
1612     linePainter = new LinePainter(getSourceViewer());
1613     linePainter.setHighlightColor(new Color(Display.getCurrent(), 225, 235, 224));
1614     //    fPaintManager.addPainter(linePainter);
1615     //    if (isBracketHighlightingEnabled())
1616     //      startBracketHighlighting();
1617     //    if (isLineHighlightingEnabled())
1618     //      startLineHighlighting();
1619     //    if (isPrintMarginVisible())
1620     //      showPrintMargin();
1621     //    Iterator e = ANNOTATION_MAP.keySet().iterator();
1622     //    while (e.hasNext()) {
1623     //      AnnotationType type = (AnnotationType) e.next();
1624     //      if (isAnnotationIndicationEnabled(type))
1625     //        startAnnotationIndication(type);
1626     //    }
1627     if (isTabConversionEnabled())
1628       startTabConversion();
1629     //    if (isOverviewRulerVisible())
1630     //      showOverviewRuler();
1631     //
1632     //    Preferences preferences =
1633     // PHPeclipsePlugin.getDefault().getPluginPreferences();
1634     //    preferences.addPropertyChangeListener(fPropertyChangeListener);
1635     IPreferenceStore preferenceStore = getPreferenceStore();
1636     boolean closeBracketsPHP = preferenceStore.getBoolean(CLOSE_BRACKETS_PHP);
1637     boolean closeStringsPHPDQ = preferenceStore.getBoolean(CLOSE_STRINGS_DQ_PHP);
1638     boolean closeStringsPHPSQ = preferenceStore.getBoolean(CLOSE_STRINGS_SQ_PHP);
1639     boolean closeBracketsHTML = preferenceStore.getBoolean(CLOSE_BRACKETS_HTML);
1640     boolean closeStringsHTML = preferenceStore.getBoolean(CLOSE_STRINGS_HTML);
1641     fBracketInserter.setCloseBracketsPHPEnabled(closeBracketsPHP);
1642     fBracketInserter.setCloseStringsPHPDQEnabled(closeStringsPHPDQ);
1643     fBracketInserter.setCloseStringsPHPSQEnabled(closeStringsPHPSQ);
1644     fBracketInserter.setCloseBracketsHTMLEnabled(closeBracketsHTML);
1645     fBracketInserter.setCloseStringsHTMLEnabled(closeStringsHTML);
1646     ISourceViewer sourceViewer = getSourceViewer();
1647     if (sourceViewer instanceof ITextViewerExtension)
1648       ((ITextViewerExtension) sourceViewer).prependVerifyKeyListener(fBracketInserter);
1649   }
1650
1651   private static char getPeerCharacter(char character) {
1652     switch (character) {
1653     case '(':
1654       return ')';
1655     case ')':
1656       return '(';
1657     case '[':
1658       return ']';
1659     case ']':
1660       return '[';
1661     case '"':
1662       return character;
1663     case '\'':
1664       return character;
1665     default:
1666       throw new IllegalArgumentException();
1667     }
1668   }
1669
1670   //  private void startBracketHighlighting() {
1671   //    if (fBracketPainter == null) {
1672   //      ISourceViewer sourceViewer = getSourceViewer();
1673   //      fBracketPainter = new BracketPainter(sourceViewer);
1674   //      fBracketPainter.setHighlightColor(getColor(MATCHING_BRACKETS_COLOR));
1675   //      // fPaintManager.addPainter(fBracketPainter);
1676   //    }
1677   //  }
1678   //
1679   //  private void stopBracketHighlighting() {
1680   //    if (fBracketPainter != null) {
1681   //      // fPaintManager.removePainter(fBracketPainter);
1682   //      fBracketPainter.deactivate(true);
1683   //      fBracketPainter.dispose();
1684   //      fBracketPainter = null;
1685   //    }
1686   //  }
1687
1688   //  private boolean isBracketHighlightingEnabled() {
1689   //    IPreferenceStore store = getPreferenceStore();
1690   //    return store.getBoolean(MATCHING_BRACKETS);
1691   //  }
1692
1693   //  private void startLineHighlighting() {
1694   //    if (fLinePainter == null) {
1695   //      ISourceViewer sourceViewer = getSourceViewer();
1696   //      fLinePainter = new LinePainter(sourceViewer);
1697   //      fLinePainter.setHighlightColor(getColor(CURRENT_LINE_COLOR));
1698   //      // fPaintManager.addPainter(fLinePainter);
1699   //    }
1700   //  }
1701
1702   //  private void stopLineHighlighting() {
1703   //    if (fLinePainter != null) {
1704   //      // fPaintManager.removePainter(fLinePainter);
1705   //      fLinePainter.deactivate(true);
1706   //      fLinePainter.dispose();
1707   //      fLinePainter = null;
1708   //    }
1709   //  }
1710
1711   //  private boolean isLineHighlightingEnabled() {
1712   //    IPreferenceStore store = getPreferenceStore();
1713   //    return store.getBoolean(CURRENT_LINE);
1714   //  }
1715
1716   //  private void showPrintMargin() {
1717   //    if (fPrintMarginPainter == null) {
1718   //      fPrintMarginPainter = new PrintMarginPainter(getSourceViewer());
1719   //      fPrintMarginPainter.setMarginRulerColor(getColor(PRINT_MARGIN_COLOR));
1720   //      fPrintMarginPainter.setMarginRulerColumn(getPreferenceStore().getInt(PRINT_MARGIN_COLUMN));
1721   //      // fPaintManager.addPainter(fPrintMarginPainter);
1722   //    }
1723   //  }
1724
1725   //  private void hidePrintMargin() {
1726   //    if (fPrintMarginPainter != null) {
1727   //      // fPaintManager.removePainter(fPrintMarginPainter);
1728   //      fPrintMarginPainter.deactivate(true);
1729   //      fPrintMarginPainter.dispose();
1730   //      fPrintMarginPainter = null;
1731   //    }
1732   //  }
1733
1734   //  private boolean isPrintMarginVisible() {
1735   //    IPreferenceStore store = getPreferenceStore();
1736   //    return store.getBoolean(PRINT_MARGIN);
1737   //  }
1738
1739   private int getTabSize() {
1740     Preferences preferences = PHPeclipsePlugin.getDefault().getPluginPreferences();
1741     return preferences.getInt(CODE_FORMATTER_TAB_SIZE);
1742   }
1743
1744   private boolean isTabConversionEnabled() {
1745     IPreferenceStore store = getPreferenceStore();
1746     return store.getBoolean(SPACES_FOR_TABS);
1747   }
1748
1749   private Color getColor(String key) {
1750     RGB rgb = PreferenceConverter.getColor(getPreferenceStore(), key);
1751     return getColor(rgb);
1752   }
1753
1754   private Color getColor(RGB rgb) {
1755     JavaTextTools textTools = PHPeclipsePlugin.getDefault().getJavaTextTools();
1756     return textTools.getColorManager().getColor(rgb);
1757   }
1758
1759   //  private Color getColor(AnnotationType annotationType) {
1760   //    AnnotationInfo info = (AnnotationInfo)
1761   // ANNOTATION_MAP.get(annotationType);
1762   //    if (info != null)
1763   //      return getColor(info.fColorPreference);
1764   //    return null;
1765   //  }
1766   public void dispose() {
1767     ISourceViewer sourceViewer = getSourceViewer();
1768     if (sourceViewer instanceof ITextViewerExtension)
1769       ((ITextViewerExtension) sourceViewer).removeVerifyKeyListener(fBracketInserter);
1770     //    if (fPropertyChangeListener != null) {
1771     //      Preferences preferences =
1772     // PHPeclipsePlugin.getDefault().getPluginPreferences();
1773     //      preferences.removePropertyChangeListener(fPropertyChangeListener);
1774     //      fPropertyChangeListener = null;
1775     //    }
1776     if (fJavaEditorErrorTickUpdater != null) {
1777       fJavaEditorErrorTickUpdater.dispose();
1778       fJavaEditorErrorTickUpdater = null;
1779     }
1780     //    if (fSelectionHistory != null)
1781     //      fSelectionHistory.dispose();
1782     //    if (fPaintManager != null) {
1783     //      fPaintManager.dispose();
1784     //      fPaintManager = null;
1785     //    }
1786     if (fActionGroups != null) {
1787       fActionGroups.dispose();
1788       fActionGroups = null;
1789     }
1790     super.dispose();
1791   }
1792
1793   //  protected AnnotationType getAnnotationType(String preferenceKey) {
1794   //    Iterator e = ANNOTATION_MAP.keySet().iterator();
1795   //    while (e.hasNext()) {
1796   //      AnnotationType type = (AnnotationType) e.next();
1797   //      AnnotationInfo info = (AnnotationInfo) ANNOTATION_MAP.get(type);
1798   //      if (info != null) {
1799   //        if (preferenceKey.equals(info.fColorPreference)
1800   //          || preferenceKey.equals(info.fEditorPreference)
1801   //          || preferenceKey.equals(info.fOverviewRulerPreference))
1802   //          return type;
1803   //      }
1804   //    }
1805   //    return null;
1806   //  }
1807   /*
1808    * @see AbstractTextEditor#handlePreferenceStoreChanged(PropertyChangeEvent)
1809    */
1810   protected void handlePreferenceStoreChanged(PropertyChangeEvent event) {
1811     try {
1812       AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1813       if (asv != null) {
1814         String p = event.getProperty();
1815         if (CLOSE_BRACKETS_PHP.equals(p)) {
1816           fBracketInserter.setCloseBracketsPHPEnabled(getPreferenceStore().getBoolean(p));
1817           return;
1818         }
1819         if (CLOSE_STRINGS_DQ_PHP.equals(p)) {
1820           fBracketInserter.setCloseStringsPHPDQEnabled(getPreferenceStore().getBoolean(p));
1821           return;
1822         }
1823         if (CLOSE_STRINGS_SQ_PHP.equals(p)) {
1824           fBracketInserter.setCloseStringsPHPSQEnabled(getPreferenceStore().getBoolean(p));
1825           return;
1826         }
1827         if (CLOSE_BRACKETS_HTML.equals(p)) {
1828           fBracketInserter.setCloseBracketsHTMLEnabled(getPreferenceStore().getBoolean(p));
1829           return;
1830         }
1831         if (CLOSE_STRINGS_HTML.equals(p)) {
1832           fBracketInserter.setCloseStringsHTMLEnabled(getPreferenceStore().getBoolean(p));
1833           return;
1834         }
1835         if (SPACES_FOR_TABS.equals(p)) {
1836           if (isTabConversionEnabled())
1837             startTabConversion();
1838           else
1839             stopTabConversion();
1840           return;
1841         }
1842         //        if (MATCHING_BRACKETS.equals(p)) {
1843         //          if (isBracketHighlightingEnabled())
1844         //            startBracketHighlighting();
1845         //          else
1846         //            stopBracketHighlighting();
1847         //          return;
1848         //        }
1849         //        if (MATCHING_BRACKETS_COLOR.equals(p)) {
1850         //          if (fBracketPainter != null)
1851         //            fBracketPainter.setHighlightColor(getColor(MATCHING_BRACKETS_COLOR));
1852         //          return;
1853         //        }
1854         //        if (CURRENT_LINE.equals(p)) {
1855         //          if (isLineHighlightingEnabled())
1856         //            startLineHighlighting();
1857         //          else
1858         //            stopLineHighlighting();
1859         //          return;
1860         //        }
1861         //        if (CURRENT_LINE_COLOR.equals(p)) {
1862         //          if (fLinePainter != null) {
1863         //            stopLineHighlighting();
1864         //            startLineHighlighting();
1865         //          }
1866         //          return;
1867         //        }
1868         //        if (PRINT_MARGIN.equals(p)) {
1869         //          if (isPrintMarginVisible())
1870         //            showPrintMargin();
1871         //          else
1872         //            hidePrintMargin();
1873         //          return;
1874         //        }
1875         //        if (PRINT_MARGIN_COLOR.equals(p)) {
1876         //          if (fPrintMarginPainter != null)
1877         //            fPrintMarginPainter.setMarginRulerColor(getColor(PRINT_MARGIN_COLOR));
1878         //          return;
1879         //        }
1880         //        if (PRINT_MARGIN_COLUMN.equals(p)) {
1881         //          if (fPrintMarginPainter != null)
1882         //            fPrintMarginPainter.setMarginRulerColumn(getPreferenceStore().getInt(PRINT_MARGIN_COLUMN));
1883         //          return;
1884         //        }
1885         //        if (OVERVIEW_RULER.equals(p)) {
1886         //          if (isOverviewRulerVisible())
1887         //            showOverviewRuler();
1888         //          else
1889         //            hideOverviewRuler();
1890         //          return;
1891         //        }
1892         //        AnnotationType type = getAnnotationType(p);
1893         //        if (type != null) {
1894         //
1895         //          AnnotationInfo info = (AnnotationInfo)
1896         // ANNOTATION_MAP.get(type);
1897         //          if (info.fColorPreference.equals(p)) {
1898         //            Color color = getColor(type);
1899         //            if (fProblemPainter != null) {
1900         //              fProblemPainter.setColor(type, color);
1901         //              fProblemPainter.paint(IPainter.CONFIGURATION);
1902         //            }
1903         //            setColorInOverviewRuler(type, color);
1904         //            return;
1905         //          }
1906         //
1907         //          if (info.fEditorPreference.equals(p)) {
1908         //            if (isAnnotationIndicationEnabled(type))
1909         //              startAnnotationIndication(type);
1910         //            else
1911         //              stopAnnotationIndication(type);
1912         //            return;
1913         //          }
1914         //
1915         //          if (info.fOverviewRulerPreference.equals(p)) {
1916         //            if (isAnnotationIndicationInOverviewRulerEnabled(type))
1917         //              showAnnotationIndicationInOverviewRuler(type, true);
1918         //            else
1919         //              showAnnotationIndicationInOverviewRuler(type, false);
1920         //            return;
1921         //          }
1922         //        }
1923         IContentAssistant c = asv.getContentAssistant();
1924         if (c instanceof ContentAssistant)
1925           ContentAssistPreference.changeConfiguration((ContentAssistant) c, getPreferenceStore(), event);
1926       }
1927     } finally {
1928       super.handlePreferenceStoreChanged(event);
1929     }
1930   }
1931
1932   /*
1933    * @see net.sourceforge.phpdt.internal.ui.javaeditor.JavaEditor#handlePreferencePropertyChanged(org.eclipse.core.runtime.Preferences.PropertyChangeEvent)
1934    */
1935   protected void handlePreferencePropertyChanged(org.eclipse.core.runtime.Preferences.PropertyChangeEvent event) {
1936     AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1937     if (asv != null) {
1938       String p = event.getProperty();
1939       if (CODE_FORMATTER_TAB_SIZE.equals(p)) {
1940         asv.updateIndentationPrefixes();
1941         if (fTabConverter != null)
1942           fTabConverter.setNumberOfSpacesPerTab(getTabSize());
1943       }
1944     }
1945     super.handlePreferencePropertyChanged(event);
1946   }
1947
1948   /**
1949    * Handles a property change event describing a change of the php core's preferences and updates the preference related editor
1950    * properties.
1951    *
1952    * @param event
1953    *          the property change event
1954    */
1955   //  protected void
1956   // handlePreferencePropertyChanged(org.eclipse.core.runtime.Preferences.PropertyChangeEvent
1957   // event) {
1958   //    AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
1959   //    if (asv != null) {
1960   //      String p = event.getProperty();
1961   //      if (CODE_FORMATTER_TAB_SIZE.equals(p)) {
1962   //        asv.updateIndentationPrefixes();
1963   //        if (fTabConverter != null)
1964   //          fTabConverter.setNumberOfSpacesPerTab(getTabSize());
1965   //      }
1966   //    }
1967   //  }
1968   /*
1969    * @see net.sourceforge.phpdt.internal.ui.javaeditor.JavaEditor#createJavaSourceViewer(org.eclipse.swt.widgets.Composite,
1970    *      org.eclipse.jface.text.source.IVerticalRuler, org.eclipse.jface.text.source.IOverviewRuler, boolean, int)
1971    */
1972   protected ISourceViewer createJavaSourceViewer(Composite parent, IVerticalRuler verticalRuler, IOverviewRuler overviewRuler,
1973       boolean isOverviewRulerVisible, int styles, IPreferenceStore store) {
1974     return new AdaptedSourceViewer(parent, verticalRuler, overviewRuler, isOverviewRulerVisible, styles, store);
1975   }
1976
1977   //  protected ISourceViewer createJavaSourceViewer(Composite parent,
1978   // IVerticalRuler ruler, int styles) {
1979   //    return new AdaptedSourceViewer(parent, ruler, styles);
1980   //  }
1981   private boolean isValidSelection(int offset, int length) {
1982     IDocumentProvider provider = getDocumentProvider();
1983     if (provider != null) {
1984       IDocument document = provider.getDocument(getEditorInput());
1985       if (document != null) {
1986         int end = offset + length;
1987         int documentLength = document.getLength();
1988         return 0 <= offset && offset <= documentLength && 0 <= end && end <= documentLength;
1989       }
1990     }
1991     return false;
1992   }
1993
1994   /*
1995    * @see net.sourceforge.phpdt.internal.ui.javaeditor.JavaEditor#getInputElement()
1996    */
1997   protected IJavaElement getInputJavaElement() {
1998     return PHPeclipsePlugin.getDefault().getWorkingCopyManager().getWorkingCopy(getEditorInput());
1999   }
2000
2001   /*
2002    * @see AbstractTextEditor#editorContextMenuAboutToShow(IMenuManager)
2003    */
2004   public void editorContextMenuAboutToShow(IMenuManager menu) {
2005     super.editorContextMenuAboutToShow(menu);
2006     ActionContext context = new ActionContext(getSelectionProvider().getSelection());
2007     fContextMenuGroup.setContext(context);
2008     fContextMenuGroup.fillContextMenu(menu);
2009     fContextMenuGroup.setContext(null);
2010   }
2011
2012   /*
2013    * @see JavaEditor#setOutlinePageInput(JavaOutlinePage, IEditorInput)
2014    */
2015   protected void setOutlinePageInput(JavaOutlinePage page, IEditorInput input) {
2016     if (page != null) {
2017       IWorkingCopyManager manager = PHPeclipsePlugin.getDefault().getWorkingCopyManager();
2018       page.setInput(manager.getWorkingCopy(input));
2019     }
2020   }
2021
2022   /*
2023    * @see AbstractTextEditor#performSaveOperation(WorkspaceModifyOperation, IProgressMonitor)
2024    */
2025   //  protected void performSaveOperation(WorkspaceModifyOperation operation,
2026   // IProgressMonitor progressMonitor) {
2027   //    IDocumentProvider p = getDocumentProvider();
2028   //    if (p instanceof PHPDocumentProvider) {
2029   //      PHPDocumentProvider cp = (PHPDocumentProvider) p;
2030   //      cp.setSavePolicy(fSavePolicy);
2031   //    }
2032   //
2033   //    try {
2034   //      super.performSaveOperation(operation, progressMonitor);
2035   //    } finally {
2036   //      if (p instanceof PHPDocumentProvider) {
2037   //        PHPDocumentProvider cp = (PHPDocumentProvider) p;
2038   //        cp.setSavePolicy(null);
2039   //      }
2040   //    }
2041   //  }
2042   /*
2043    * @see AbstractTextEditor#doSave(IProgressMonitor)
2044    */
2045   public void doSave(IProgressMonitor progressMonitor) {
2046
2047     IDocumentProvider p = getDocumentProvider();
2048     if (p == null) {
2049       // editor has been closed
2050       return;
2051     }
2052
2053     if (p.isDeleted(getEditorInput())) {
2054
2055       if (isSaveAsAllowed()) {
2056
2057         /*
2058          * 1GEUSSR: ITPUI:ALL - User should never loose changes made in the editors. Changed Behavior to make sure that if called
2059          * inside a regular save (because of deletion of input element) there is a way to report back to the caller.
2060          */
2061         performSaveAs(progressMonitor);
2062
2063       } else {
2064
2065         /*
2066          * 1GF5YOX: ITPJUI:ALL - Save of delete file claims it's still there Missing resources.
2067          */
2068         Shell shell = getSite().getShell();
2069         MessageDialog
2070             .openError(
2071                 shell,
2072                 PHPEditorMessages.getString("PHPUnitEditor.error.saving.title1"), PHPEditorMessages.getString("PHPUnitEditor.error.saving.message1")); //$NON-NLS-1$ //$NON-NLS-2$
2073       }
2074
2075     } else {
2076       if (getPreferenceStore().getBoolean(PreferenceConstants.EDITOR_P_RTRIM_ON_SAVE)) {
2077         RTrimAction trimAction = new RTrimAction();
2078         trimAction.setActiveEditor(null, getSite().getPage().getActiveEditor());
2079         trimAction.run(null);
2080       }
2081
2082       setStatusLineErrorMessage(null);
2083
2084       updateState(getEditorInput());
2085       validateState(getEditorInput());
2086
2087       IWorkingCopyManager manager = PHPeclipsePlugin.getDefault().getWorkingCopyManager();
2088       ICompilationUnit unit = manager.getWorkingCopy(getEditorInput());
2089
2090       if (unit != null) {
2091         synchronized (unit) {
2092           performSave(false, progressMonitor);
2093         }
2094       } else
2095         performSave(false, progressMonitor);
2096     }
2097   }
2098
2099   public boolean isSaveAsAllowed() {
2100     return true;
2101   }
2102
2103   /**
2104    * The compilation unit editor implementation of this <code>AbstractTextEditor</code> method asks the user for the workspace
2105    * path of a file resource and saves the document there. See http://dev.eclipse.org/bugs/show_bug.cgi?id=6295
2106    *
2107    * @param progressMonitor
2108    *          the progress monitor
2109    */
2110   protected void performSaveAs(IProgressMonitor progressMonitor) {
2111
2112     Shell shell = getSite().getShell();
2113     IEditorInput input = getEditorInput();
2114
2115     SaveAsDialog dialog = new SaveAsDialog(shell);
2116
2117     IFile original = (input instanceof IFileEditorInput) ? ((IFileEditorInput) input).getFile() : null;
2118     if (original != null)
2119       dialog.setOriginalFile(original);
2120
2121     dialog.create();
2122
2123     IDocumentProvider provider = getDocumentProvider();
2124     if (provider == null) {
2125       // editor has been programmatically closed while the dialog was open
2126       return;
2127     }
2128
2129     if (provider.isDeleted(input) && original != null) {
2130       String message = PHPEditorMessages.getFormattedString(
2131           "CompilationUnitEditor.warning.save.delete", new Object[] { original.getName() }); //$NON-NLS-1$
2132       dialog.setErrorMessage(null);
2133       dialog.setMessage(message, IMessageProvider.WARNING);
2134     }
2135
2136     if (dialog.open() == Window.CANCEL) {
2137       if (progressMonitor != null)
2138         progressMonitor.setCanceled(true);
2139       return;
2140     }
2141
2142     IPath filePath = dialog.getResult();
2143     if (filePath == null) {
2144       if (progressMonitor != null)
2145         progressMonitor.setCanceled(true);
2146       return;
2147     }
2148
2149     IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
2150     IFile file = workspaceRoot.getFile(filePath);
2151     final IEditorInput newInput = new FileEditorInput(file);
2152
2153     boolean success = false;
2154     try {
2155
2156       provider.aboutToChange(newInput);
2157       getDocumentProvider().saveDocument(progressMonitor, newInput, getDocumentProvider().getDocument(getEditorInput()), true);
2158       success = true;
2159
2160     } catch (CoreException x) {
2161       IStatus status = x.getStatus();
2162       if (status == null || status.getSeverity() != IStatus.CANCEL)
2163         ErrorDialog
2164             .openError(
2165                 shell,
2166                 PHPEditorMessages.getString("CompilationUnitEditor.error.saving.title2"), PHPEditorMessages.getString("CompilationUnitEditor.error.saving.message2"), x.getStatus()); //$NON-NLS-1$ //$NON-NLS-2$
2167     } finally {
2168       provider.changed(newInput);
2169       if (success)
2170         setInput(newInput);
2171     }
2172
2173     if (progressMonitor != null)
2174       progressMonitor.setCanceled(!success);
2175   }
2176
2177   /*
2178    * @see AbstractTextEditor#doSetInput(IEditorInput)
2179    */
2180   protected void doSetInput(IEditorInput input) throws CoreException {
2181     super.doSetInput(input);
2182     configureTabConverter();
2183     configureToggleCommentAction();
2184   }
2185
2186   //    /*
2187   //     * @see
2188   // net.sourceforge.phpdt.internal.ui.javaeditor.JavaEditor#installOverrideIndicator(boolean)
2189   //     * @since 3.0
2190   //     */
2191   //    protected void installOverrideIndicator(boolean waitForReconcilation) {
2192   //            IAnnotationModel model=
2193   // getDocumentProvider().getAnnotationModel(getEditorInput());
2194   //            if (!waitForReconcilation)
2195   //                    super.installOverrideIndicator(false);
2196   //            else {
2197   //                    uninstallOverrideIndicator();
2198   //                    IJavaElement inputElement= getInputJavaElement();
2199   //                    if (model == null || inputElement == null)
2200   //                            return;
2201   //
2202   //                    fOverrideIndicatorManager= new OverrideIndicatorManager(model,
2203   // inputElement, null);
2204   //                    addReconcileListener(fOverrideIndicatorManager);
2205   //            }
2206   //    }
2207   //
2208   //    /*
2209   //     * @see
2210   // net.sourceforge.phpdt.internal.ui.javaeditor.JavaEditor#uninstallOverrideIndicator()
2211   //     * @since 3.0
2212   //     */
2213   //    protected void uninstallOverrideIndicator() {
2214   //            if (fOverrideIndicatorManager != null)
2215   //                    removeReconcileListener(fOverrideIndicatorManager);
2216   //            super.uninstallOverrideIndicator();
2217   //    }
2218
2219   /**
2220    * Configures the toggle comment action
2221    *
2222    * @since 3.0
2223    */
2224   private void configureToggleCommentAction() {
2225     IAction action = getAction("ToggleComment"); //$NON-NLS-1$
2226     if (action instanceof ToggleCommentAction) {
2227       ISourceViewer sourceViewer = getSourceViewer();
2228       SourceViewerConfiguration configuration = getSourceViewerConfiguration();
2229       ((ToggleCommentAction) action).configure(sourceViewer, configuration);
2230     }
2231   }
2232
2233   //  private void configureTabConverter() {
2234   //    if (fTabConverter != null) {
2235   //      IDocumentProvider provider = getDocumentProvider();
2236   //      if (provider instanceof PHPDocumentProvider) {
2237   //        PHPDocumentProvider cup = (PHPDocumentProvider) provider;
2238   //        fTabConverter.setLineTracker(cup.createLineTracker(getEditorInput()));
2239   //      }
2240   //    }
2241   //  }
2242   private void configureTabConverter() {
2243     if (fTabConverter != null) {
2244       IDocumentProvider provider = getDocumentProvider();
2245       if (provider instanceof ICompilationUnitDocumentProvider) {
2246         ICompilationUnitDocumentProvider cup = (ICompilationUnitDocumentProvider) provider;
2247         fTabConverter.setLineTracker(cup.createLineTracker(getEditorInput()));
2248       }
2249     }
2250   }
2251
2252   private void startTabConversion() {
2253     if (fTabConverter == null) {
2254       fTabConverter = new TabConverter();
2255       configureTabConverter();
2256       fTabConverter.setNumberOfSpacesPerTab(getTabSize());
2257       AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
2258       asv.addTextConverter(fTabConverter);
2259       // http://dev.eclipse.org/bugs/show_bug.cgi?id=19270
2260       asv.updateIndentationPrefixes();
2261     }
2262   }
2263
2264   private void stopTabConversion() {
2265     if (fTabConverter != null) {
2266       AdaptedSourceViewer asv = (AdaptedSourceViewer) getSourceViewer();
2267       asv.removeTextConverter(fTabConverter);
2268       // http://dev.eclipse.org/bugs/show_bug.cgi?id=19270
2269       asv.updateIndentationPrefixes();
2270       fTabConverter = null;
2271     }
2272   }
2273
2274   /*
2275    * @see org.eclipse.ui.texteditor.AbstractTextEditor#performSave(boolean, org.eclipse.core.runtime.IProgressMonitor)
2276    */
2277   protected void performSave(boolean overwrite, IProgressMonitor progressMonitor) {
2278     //    IDocumentProvider p = getDocumentProvider();
2279     //    if (p instanceof PHPDocumentProvider) {
2280     //      PHPDocumentProvider cp = (PHPDocumentProvider) p;
2281     //      cp.setSavePolicy(fSavePolicy);
2282     //    }
2283     //    try {
2284     //      super.performSave(overwrite, progressMonitor);
2285     //    } finally {
2286     //      if (p instanceof PHPDocumentProvider) {
2287     //        PHPDocumentProvider cp = (PHPDocumentProvider) p;
2288     //        cp.setSavePolicy(null);
2289     //      }
2290     //    }
2291
2292     IDocumentProvider p = getDocumentProvider();
2293     if (p instanceof ICompilationUnitDocumentProvider) {
2294       ICompilationUnitDocumentProvider cp = (ICompilationUnitDocumentProvider) p;
2295       cp.setSavePolicy(fSavePolicy);
2296     }
2297     try {
2298       super.performSave(overwrite, progressMonitor);
2299     } finally {
2300       if (p instanceof ICompilationUnitDocumentProvider) {
2301         ICompilationUnitDocumentProvider cp = (ICompilationUnitDocumentProvider) p;
2302         cp.setSavePolicy(null);
2303       }
2304     }
2305   }
2306
2307   /*
2308    * @see AbstractTextEditor#doSaveAs
2309    */
2310   public void doSaveAs() {
2311     if (askIfNonWorkbenchEncodingIsOk()) {
2312       super.doSaveAs();
2313     }
2314   }
2315
2316   /**
2317    * Asks the user if it is ok to store in non-workbench encoding.
2318    *
2319    * @return <true>if the user wants to continue
2320    */
2321   private boolean askIfNonWorkbenchEncodingIsOk() {
2322     IDocumentProvider provider = getDocumentProvider();
2323     if (provider instanceof IStorageDocumentProvider) {
2324       IEditorInput input = getEditorInput();
2325       IStorageDocumentProvider storageProvider = (IStorageDocumentProvider) provider;
2326       String encoding = storageProvider.getEncoding(input);
2327       String defaultEncoding = storageProvider.getDefaultEncoding();
2328       if (encoding != null && !encoding.equals(defaultEncoding)) {
2329         Shell shell = getSite().getShell();
2330         String title = PHPEditorMessages.getString("PHPUnitEditor.warning.save.nonWorkbenchEncoding.title"); //$NON-NLS-1$
2331         String msg;
2332         if (input != null)
2333           msg = MessageFormat.format(PHPEditorMessages.getString("PHPUnitEditor.warning.save.nonWorkbenchEncoding.message1"),
2334               new String[] { input.getName(), encoding }); //$NON-NLS-1$
2335         else
2336           msg = MessageFormat.format(PHPEditorMessages.getString("PHPUnitEditor.warning.save.nonWorkbenchEncoding.message2"),
2337               new String[] { encoding }); //$NON-NLS-1$
2338         return MessageDialog.openQuestion(shell, title, msg);
2339       }
2340     }
2341     return true;
2342   }
2343
2344   /*
2345    * @see net.sourceforge.phpdt.internal.ui.text.java.IJavaReconcilingListener#aboutToBeReconciled()
2346    * @since 3.0
2347    */
2348   public void aboutToBeReconciled() {
2349
2350     // Notify AST provider
2351     //          PHPeclipsePlugin.getDefault().getASTProvider().aboutToBeReconciled(getInputJavaElement());
2352
2353     // Notify listeners
2354     Object[] listeners = fReconcilingListeners.getListeners();
2355     for (int i = 0, length = listeners.length; i < length; ++i)
2356       ((IJavaReconcilingListener) listeners[i]).aboutToBeReconciled();
2357   }
2358
2359   /*
2360    * @see net.sourceforge.phpdt.internal.ui.text.java.IJavaReconcilingListener#reconciled(CompilationUnit, boolean,
2361    *      IProgressMonitor)
2362    * @since 3.0
2363    */
2364   public void reconciled(CompilationUnit ast, boolean forced, IProgressMonitor progressMonitor) {
2365
2366     // Always notify AST provider
2367     //          PHPeclipsePlugin.getDefault().getASTProvider().reconciled(ast, getInputJavaElement());
2368
2369     // Notify listeners
2370     //          Object[] listeners = fReconcilingListeners.getListeners();
2371     //          for (int i = 0, length= listeners.length; i < length; ++i)
2372     //                  ((IJavaReconcilingListener)listeners[i]).reconciled(ast, forced, progressMonitor);
2373
2374     // Update Java Outline page selection
2375     if (!forced && !progressMonitor.isCanceled()) {
2376       Shell shell = getSite().getShell();
2377       if (shell != null && !shell.isDisposed()) {
2378         shell.getDisplay().asyncExec(new Runnable() {
2379           public void run() {
2380             selectionChanged();
2381           }
2382         });
2383       }
2384     }
2385   }
2386
2387   /**
2388    * Returns the updated java element for the old java element.
2389    */
2390   private IJavaElement findElement(IJavaElement element) {
2391     if (element == null)
2392       return null;
2393     IWorkingCopyManager manager = PHPeclipsePlugin.getDefault().getWorkingCopyManager();
2394     ICompilationUnit unit = manager.getWorkingCopy(getEditorInput());
2395     if (unit != null) {
2396       try {
2397         synchronized (unit) {
2398           unit.reconcile();
2399         }
2400         IJavaElement[] findings = unit.findElements(element);
2401         if (findings != null && findings.length > 0)
2402           return findings[0];
2403       } catch (JavaModelException x) {
2404         PHPeclipsePlugin.log(x.getStatus());
2405         // nothing found, be tolerant and go on
2406       }
2407     }
2408     return null;
2409   }
2410
2411   /**
2412    * Returns the offset of the given Java element.
2413    */
2414   private int getOffset(IJavaElement element) {
2415     if (element instanceof ISourceReference) {
2416       ISourceReference sr = (ISourceReference) element;
2417       try {
2418         ISourceRange srcRange = sr.getSourceRange();
2419         if (srcRange != null)
2420           return srcRange.getOffset();
2421       } catch (JavaModelException e) {
2422       }
2423     }
2424     return -1;
2425   }
2426
2427   /*
2428    * @see AbstractTextEditor#restoreSelection()
2429    */
2430   //  protected void restoreSelection() {
2431   //    try {
2432   //      if (getSourceViewer() == null || fRememberedSelection == null)
2433   //        return;
2434   //      IJavaElement newElement = findElement(fRememberedElement);
2435   //      int newOffset = getOffset(newElement);
2436   //      int delta = (newOffset > -1 && fRememberedElementOffset > -1) ? newOffset
2437   //          - fRememberedElementOffset : 0;
2438   //      if (isValidSelection(delta + fRememberedSelection.getOffset(),
2439   //          fRememberedSelection.getLength()))
2440   //        selectAndReveal(delta + fRememberedSelection.getOffset(),
2441   //            fRememberedSelection.getLength());
2442   //    } finally {
2443   //      fRememberedSelection = null;
2444   //      fRememberedElement = null;
2445   //      fRememberedElementOffset = -1;
2446   //    }
2447   //  }
2448   /**
2449    * Tells whether this is the active editor in the active page.
2450    *
2451    * @return <code>true</code> if this is the active editor in the active page
2452    * @see IWorkbenchPage#getActiveEditor();
2453    */
2454   protected final boolean isActiveEditor() {
2455     IWorkbenchWindow window = getSite().getWorkbenchWindow();
2456     IWorkbenchPage page = window.getActivePage();
2457     if (page == null)
2458       return false;
2459     IEditorPart activeEditor = page.getActiveEditor();
2460     return activeEditor != null && activeEditor.equals(this);
2461   }
2462
2463   /**
2464    * Adds the given listener. Has no effect if an identical listener was not already registered.
2465    *
2466    * @param listener
2467    *          The reconcile listener to be added
2468    * @since 3.0
2469    */
2470   final void addReconcileListener(IJavaReconcilingListener listener) {
2471     synchronized (fReconcilingListeners) {
2472       fReconcilingListeners.add(listener);
2473     }
2474   }
2475
2476   /**
2477    * Removes the given listener. Has no effect if an identical listener was not already registered.
2478    *
2479    * @param listener
2480    *          the reconcile listener to be removed
2481    * @since 3.0
2482    */
2483   final void removeReconcileListener(IJavaReconcilingListener listener) {
2484     synchronized (fReconcilingListeners) {
2485       fReconcilingListeners.remove(listener);
2486     }
2487   }
2488
2489   protected void updateStateDependentActions() {
2490     super.updateStateDependentActions();
2491     fGenerateActionGroup.editorStateChanged();
2492   }
2493
2494   /*
2495    * @see AbstractTextEditor#rememberSelection()
2496    */
2497   protected void rememberSelection() {
2498     fRememberedSelection.remember();
2499   }
2500
2501   /*
2502    * @see AbstractTextEditor#restoreSelection()
2503    */
2504   protected void restoreSelection() {
2505     fRememberedSelection.restore();
2506   }
2507
2508   /*
2509    * @see AbstractTextEditor#canHandleMove(IEditorInput, IEditorInput)
2510    */
2511   protected boolean canHandleMove(IEditorInput originalElement, IEditorInput movedElement) {
2512
2513     String oldExtension = ""; //$NON-NLS-1$
2514     if (originalElement instanceof IFileEditorInput) {
2515       IFile file = ((IFileEditorInput) originalElement).getFile();
2516       if (file != null) {
2517         String ext = file.getFileExtension();
2518         if (ext != null)
2519           oldExtension = ext;
2520       }
2521     }
2522
2523     String newExtension = ""; //$NON-NLS-1$
2524     if (movedElement instanceof IFileEditorInput) {
2525       IFile file = ((IFileEditorInput) movedElement).getFile();
2526       if (file != null)
2527         newExtension = file.getFileExtension();
2528     }
2529
2530     return oldExtension.equals(newExtension);
2531   }
2532
2533   /*
2534    * @see org.eclipse.ui.texteditor.AbstractDecoratedTextEditor#isPrefQuickDiffAlwaysOn()
2535    */
2536   protected boolean isPrefQuickDiffAlwaysOn() {
2537     // reestablishes the behaviour from AbstractDecoratedTextEditor which was hacked by JavaEditor
2538     // to disable the change bar for the class file (attached source) java editor.
2539     IPreferenceStore store = getPreferenceStore();
2540     return store.getBoolean(AbstractDecoratedTextEditorPreferenceConstants.QUICK_DIFF_ALWAYS_ON);
2541   }
2542
2543   /*
2544    * @see net.sourceforge.phpdt.internal.ui.javaeditor.JavaEditor#getAdapter(java.lang.Class)
2545    */
2546   public Object getAdapter(Class required) {
2547     if (SmartBackspaceManager.class.equals(required)) {
2548       if (getSourceViewer() instanceof JavaSourceViewer) {
2549         return ((JavaSourceViewer) getSourceViewer()).getBackspaceManager();
2550       }
2551     }
2552
2553     return super.getAdapter(required);
2554   }
2555
2556   /**
2557    * Returns the mutex for the reconciler. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=63898 for a description of the problem.
2558    * <p>
2559    * TODO remove once the underlying problem is solved.
2560    * </p>
2561    *
2562    * @return the lock reconcilers may use to synchronize on
2563    */
2564   public Object getReconcilerLock() {
2565     return fReconcilerLock;
2566   }
2567
2568   /*
2569    * (non-Javadoc)
2570    *
2571    * @see org.eclipse.ui.texteditor.AbstractTextEditor#editorSaved()
2572    */
2573   protected void editorSaved() {
2574     super.editorSaved();
2575     ShowExternalPreviewAction a = ShowExternalPreviewAction.getInstance();
2576     if (a != null) {
2577       a.refresh(ShowExternalPreviewAction.PHP_TYPE);
2578     }
2579   }
2580 }