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