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