net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/phpeditor/PHPUnitEditor.java

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