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